Cours Algorithme et Programmation 2024-2025

Institut Supérieur des sciences appliquées

et de technologie de Sousse

SUPPORT DE COURS

Algorithme et Programmation (Le Langage C)

Semestre 2

Auditoire :

1ére année Licence Électronique, Électrotechnique et

Automatique - LEEA

Année Universitaire : 2024-2025

1
Cours Algorithme et Programmation 2024-2025

PLAN DU COURS

Chapitre 1 : Introduction à la programmation

Chapitre 2 : Type de base, opérateurs et expressions

Chapitre 3 : Opérations de Lecture/Ecriture

Chapitre 4 : La structure alternative

Chapitre 5 : La structure répétitive

Chapitre 6 : Les tableaux

2
Cours Algorithme et Programmation 2024-2025

3
Cours Algorithme et Programmation 2024-2025

Chapitre 1 :

Introduction à la programmation

- Les étapes d’automatisation d’un problème avec le langage C

- Le langage C : historique
- Structure d’un programme en langage C
1.1. Etape d’automatisation d’un problème avec le langage C

Problème

Analyse

Algorithme

Traduction à un langage de programmation

évolué (langage C)
Programme source
(.cpp en lge C)

Compilation (réalisée par le compilateur)

Programme objet
(.obj)

Edition de lien (réalisée par l’éditeur de lien)

Programme
exécutable (.exe)

Un langage de programmation évolué (langage de haut niveau) est un langage

informatique indépendant de toute machine : exemple : C, C++, C#, Pascal, java, etc.…
Un programme écrit en langage évolué, appelé programme source, est plus facile à lire et à
comprendre parce qu’il est plus proche du langage humain. Il y a essentiellement deux sortes
de programmes traducteurs pour ce genre de langage : les compilateurs et les interpréteurs.
Un compilateur est un logiciel traduisant la totalité du programme en un programme
exécutable. Il permet d’analyser la syntaxe des instructions et de détecter les erreurs de
syntaxe si elles existent.
Un interpréteur traduit les instructions du programme source l’une après l’autre et les
exécute au fur et à mesure.
Un éditeur de liens permet de lier les objets aux bibliothèques du langage de programmation.
1.2. Le langage C : historique

4
Cours Algorithme et Programmation 2024-2025

- Le langage C a été crée par Dennis M. Ritchie en 1972 dans « Bell Laboratories » avec un
objectif relativement limité : développer une version portable du système d’exploitation
UNIX.
- En 1978, Dennis M. Ritchie et Brian W. Kernighan ont publié la définition classique du
langage C dans un livre intitulé « The C Programming Language ».
- En 1983, le langage C est devenu un standard ANSI-C suite à une commission réalisée
dans « American National Standards Instituté (ANSI) ».
- La seconde édition du livre « The C Programming Language » est parue en 1988, elle
respecte tout à fait le standard ANSI-C et elle est devenue par la suite, la « bible » des
programmeurs en C.
- Le C est un langage de procédures de haut niveau. Il est conçu pour fonctionner avec des
techniques de programmation structurée. Ses qualités « opérationnelles » l’ont très vite
fait adopté par une large communauté de programmeurs.
I. 3. Structure d’un programme en C
Un programme en C est une suite d’instruction manipulant des objets (variables ou des
constantes) regroupées en une ou plusieurs fonctions.
 Une fonction :
Une fonction en C est constituée :
- D’une entête (type et nom de la fonction suivis d’une liste d’arguments entre
parenthèses),
- D’instructions composées constituant le corps de la fonction délimitées par des
accolades {}.
 Une instruction :
Une instruction en C se termine toujours par un point virgule ; Ex : int a=5 ;
Plusieurs instructions peuvent être rassemblées par des accolades {} pour former une
instruction composée ou bloc qui est syntaxiquement équivalent à une instruction.
 La fonction main :
Dite encore fonction principale qui doit être toujours présente. L’exécution du programme C
commence toujours main.
 Une variable :
Une variable est un objet défini par un nom et un type dont la valeur peut être modifiée
pendant l’exécution du programme.
Les types de base sont :
- Les entiers,
- Les caractères,
- Les flottants (réels).
 Un identificateur :
Un identificateur est le nom donné à diverse composantes d’un programme (variable, tableau,
…) :
- Le nom est formé de lettre (maj ou min), de chiffres et du caractère « _ ».
- Le premier caractère ne doit pas être un chiffre.
- La longueur maximale d’un identificateur est de 31 caractères.
Remarque :

5
Cours Algorithme et Programmation 2024-2025

Le langage C est un langage à mots-clés, ce qui signifie qu’un certain nombre de mots sont
réservés pour le langage lui-même et ne peuvent donc pas être utilisés comme identificateurs.

La liste exhaustive des mots-clés est la suivante :

auto double int struct
break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while

 Un commentaire :
Un commentaire est utilisé dans un programme pour faciliter sa compréhension. Il n’est pas
compilé et n’est pas pour le programmeur. Un commentaire peut s’étendre sur plusieurs lignes
délimités par /* et */ ou sur une seule ligne précédé par deux slashs //.
Reprenons le programme précédent :
#include <stdio.h> bibliothèque standard d’input output
void main() fonction principale
{ début de la fonction main
// Notre premier programme en C commentaire
printf("Bonjour Tout le monde!\n"); fonction de la bibliothèque <stdio.h>
} fin de la fonction main

6
Cours Algorithme et Programmation 2024-2025

Chapitre 2 :

Type de base, opérateurs et expressions

- Types de base
 Les types simples : types entiers : types entiers et types rationnels,
 La déclaration des variables simples, constantes numériques et initialisation
des variables
- Les opérateurs connus
 L’affectation standard
 Les opérateurs arithmétiques,
 Les opérateurs logiques,
 Les opérateurs de comparaison.
- Les opérateurs particuliers
 L’affectation particulière,
 L’incrémentation,
 La décrémentation.
- Les expressions
- La priorité des opérateurs
- Les opérateurs arithmétiques standards
- Les conversions de types : automatiques et forcées

7
Cours Algorithme et Programmation 2024-2025

Introduction
Le C est un langage typé. Cela signifie en particulier que toute variable, constante ou fonction
est d’un type précis. Le type d’un objet définit la façon dont il et représenté en mémoire. La
taille mémoire correspondant aux différents types dépend des compilateurs (8bits, 16bits,
32bits) ; toutefois, la norme ANSI spécifie un certain nombre de contraintes.
I. Les types simples

I.1. Les types entiers

Avant de pouvoir utiliser une variable, on doit s'intéresser à deux caractéristiques de son type:
(1) le domaine des valeurs admissibles
(2) le nombre d'octets qui est réservé pour une variable
Le tableau suivant résume les caractéristiques des types numériques entiers de C :
définition description domaine min domaine max nombre d'octets
char caractère -128 127 1
short entier court -32768 32767 2
int entier standard -32768 32767 2
long entier long -2147483648 2147483647 4
Tableau 1. Les caractéristiques des types numériques entiers de C
Les modificateurs signed/unsigned: Si on ajoute le préfixe unsigned à la définition d'un type
de variables entières, les domaines des variables sont déplacés comme suit:

définition description domaine min domaine max nombre d'octets

Unsigned char caractère 0 255 1
Unsigned short entier court 0 65535 2
Unsigned int entier standard 0 65535 2
Unsigned long entier long 0 4294967295 4
Tableau 2. Les domaines des variables
I.2. Les types rationnels

En informatique, les rationnels sont souvent appelés des 'flottants'.

<+|-> <mantisse> * 10<exposant>

Exemples : 1.25003*10 ; -1.5*103
-12

<mantisse> : est un décimal positif avec un seul chiffre devant la virgule.

En C, nous avons le choix entre trois types de rationnels: float, double et long double.
définition précision mantisse domaine min domaine max nombre d'octets
float simple 6 3.4 * 10-38 3.4 * 1038 4
double double 15 1.7 * 10-308 1.7 * 10308 8
long double suppl. 19 3.4 * 10-4932 1.1 * 104932 10
Tableau 3. Le choix entre trois types de rationnels

8
Cours Algorithme et Programmation 2024-2025

<mantisse> : indique le nombre de chiffres significatifs de la mantisse.

Le tableau représente les valeurs positives. Les valeurs négatives peuvent varier dans les
mêmes domaines.
II. La déclaration des variables simples
<Type> <NomVar1>,<NomVar2>,...,<NomVarN>
Exemples : int compteur, X,Y ; float hauteur, largeur ; char touche ;
Remarques :
- En C, il n’existe pas le type chaîne de caractères.
- En C standard il n’existe pas le type booléen, mais dans Visual C++.
Exemple : bool trouve ;
II.1 Les constantes entières
 Type automatique
Lors de l'attribution d'un type à une constante entière, C choisit en général la solution la plus
économique:
* Si possible, les constantes entières obtiennent le type int.
* Si le nombre est trop grand pour int (ex: 40000) il aura automatiquement le type long.
* Si le nombre est trop grand pour long, il aura le type unsigned long.
* Si le nombre est trop grand pour unsigned long, la réaction du programme est imprévisible.
 Type forcé
Si nous voulons forcer l'ordinateur à utiliser un type de notre choix, nous pouvons employer
les suffixes suivants:
suffixe type Exemple
u ou U unsigned (int ou long) 550u
l ou L long 123456789L
ul ou UL unsigned long 12092UL
Tableau 4. Les suffixes des entiers
Exemples : 12345 type int 52000type long 22luerreur
 Base octale et hexadécimale
Il est possible de déclarer des constantes entières en utilisant la base octale ou hexadécimale:
* Si une constante entière commence par 0 (zéro), alors elle est interprétée en base octale.
* Si une constante entière commence par 0x ou 0X, alors elle est interprétée en base
hexadécimale.

9
Cours Algorithme et Programmation 2024-2025

Exemples :
base décimale base octale base hexadécimale représ. binaire
100 0144 0X64 1100100
255 0377 0xff 11111111

Tableau 5. Base octale et hexadécimale

II.2 Les constantes rationnelles

Les constantes rationnelles peuvent être indiquées:
* en notation décimale, c.-à-d. à l'aide d'un point décimal: Exemples 123.4 -0.001 1.0
* en notation exponentielle, c.-à-d. à l'aide d'un exposant séparé du nombre décimal par les
caractères 'e' ou 'E': Exemples : 1234e-1 -1E-3 0.01E2
 Type automatique
Par défaut, les constantes rationnelles sont du type double.
 Type forcé
* Le suffixe f ou F force l'utilisation du type float pour les constantes rationnelles.
* Le suffixe l ou L force l'utilisation du type long double pour les constantes rationnelles.
II.3 Les caractères constants
Les constantes qui désignent un (seul) caractère sont toujours indiquées entre des apostrophes:
par exemple 'x'. La valeur d'un caractère constant est le code interne de ce caractère. Ce code
(ici: le code ASCII) est dépendant de la machine.
Les Séquences d'échappement
\a sonnerie \\ trait oblique
\b curseur arrière \? point d'interrogation
\t tabulation \' apostrophe
\n nouvelle ligne \" guillemets
\r Retour au début de ligne \f saut de page (imprimante)
\0 NUL \v tabulateur vertical
Tableau 6. Les séquences d’échappement
II.4 Déclaration et Initialisation des variables
En C, il est possible d’initialiser les variables lors de leur déclaration : int MAX=1023 ;
En utilisant l’attribut const, nous pouvons indiquer que la valeur d’une variable ne change pas
au cours d’un programme : const int MAX=767; const double e=2.718182845905 ;
III. Les opérateurs standard
III.1 Les opérateurs connus :
 Opérateur d’affectation standard
Affectation en langage algorithmique Affectation en C
<NomVariable> ranger <Expression> <NomVariable> = <Expression>;
Exemples : PI=3.1415926 ; VALEUR=X ; MOYENNE=(A+B)/2 ;
 Opérateurs arithmétiques

10
Cours Algorithme et Programmation 2024-2025

+ addition
- soustraction
* multiplication
/ division (entière et rationnelle!)
% modulo (reste d'une div. entière)
Tableau 7. Les opérateurs arithmétiques
 Opérateurs logiques  Opérateurs de comparaison
&& Et logique (and) == égal à
|| Ou logique (or) != différent de
! négation logique (not) <, <=, >, >= plus petit que, ...
Tableau 8. Les opérateurs logiques Tableau 9. Les opérateurs de comparaison

Les résultats des opérations de comparaison et des opérateurs logiques sont du type int:
- la valeur 1 correspond à la valeur booléenne vrai
- la valeur 0 correspond à la valeur booléenne faux
Les opérateurs logiques considèrent toute valeur différente de zéro comme vrai et zéro
comme faux:
32 && 2.3 1
!65.34 0
0||!(32 > 12) 0
III.2 Les opérateurs particuliers de C
 Opérateurs d'affectation
En pratique, nous retrouvons souvent des affectations comme: i = i + 2
En C, nous utiliserons plutôt la formulation plus compacte: i += 2 (+= est un opérateur
d'affectation).
+= ajouter à
-= Diminuer de
*= multiplier par
/= diviser par
%= modulo
Tableau 10. Les opérateurs d’affectation

 Opérateurs d'incrémentation et de décrémentation

Les affectations les plus fréquentes sont du type:

I=I+1 et I=I-1

En C, nous disposons de deux opérateurs inhabituels pour ces affectations:

11
Cours Algorithme et Programmation 2024-2025

I++ ou ++I pour l'incrémentation (augmentation d'une unité)

I—ou –I pour la décrémentation (diminution d'une unité)
Tableau 11. Les opérateurs d'incrémentation et de décrémentation

Les opérateurs ++ et -- sont employés dans les cas suivants:

incrémenter/décrémenter une variable ([Link]: dans une boucle). Dans ce cas il n'y a pas de
différence entre la notation préfixe (++I --I) et la notation postfixe (I++ I--).

incrémenter/décrémenter une variable et en même temps affecter sa valeur à une autre

variable. Dans ce cas, nous devons choisir entre la notation préfixe et postfixe:

X = I++ passe d'abord la valeur de I à X et incrémente après

X = I-- passe d'abord la valeur de I à X et décrémente après
X = ++I incrémente d'abord et passe la valeur incrémentée à X
X = --I décrémente d'abord et passe la valeur décrémentée à X
Tableau 12. Les opérateurs d'incrémentation et de décrémentation après et avant

Exemple : Supposons que la valeur de N est égal à 5:

Incrém. postfixe: X = N++; Résultat: N=6 et X=5

Incrém. préfixe: X = ++N; Résultat: N=6 et X=6

VI. Les expressions et les instructions

 Expressions
Exemples
i =0
i++
X=pow(A,4)
printf(" Bonjour !\n")
 Instructions
Une expression comme I=0 ou I++ ou printf(...) devient une instruction, si elle est suivie
d'un point-virgule.
Exemples
i=0;
i++;
X=pow(A,4);
printf(" Bonjour !\n");
En C toutes les expressions sont évaluées et retournent une valeur comme résultat :

(3+2==5) retourne la valeur 1 (vrai)

A=5+3 retourne la valeur 8

12
Cours Algorithme et Programmation 2024-2025

V. Les priorités des opérateurs

Priorité Opérateur Evaluation dans l’expression
1 : (la plus forte) () De gauche à droite
2 : (opérateur unaire) !++- De droite à gauche
3: */% De gauche à droite
4: +- De gauche à droite
5: < <= > >= De gauche à droite
6: == != De gauche à droite
7: && De gauche à droite
8: || De gauche à droite
9 : (opérateurs d’affectation) = += -= *= /= %= De droite à gauche
Tableau .13 Les priorités des opérateurs

L’ordre de priorité des opérations est représenté de la plus forte à la plus faible dans ce
tableau. Si plusieurs opérateurs apparaissent dans la même classe alors l’opérateur qui
apparaît le premier dans l’expression est évalué le premier (de gauche à droite) à l’exception
de deux classes (2 et 9) ou l’évaluation commence de droite à gauche.

V.I Les fonctions arithmétiques standard

Les fonctions suivantes sont prédéfinies dans la bibliothèque standard <math>. Pour pouvoir
les utiliser, le programme doit contenir la ligne: #include <math.h>
Les arguments et les résultats des fonctions arithmétiques sont du type double.
 Fonctions arithmétiques les plus courantes

Fonction en C Explication Langage algorithmique

Exp(x) fonction exponentielle ex
Log(x) Logarithme naturel Ln(x), x>0
Log10(x) Logarithme à base 10 Log10(x)
Pow(x, y) X exposant Y Xy
Sqrt(x) Racine carrée de X Pour x>0
Fabs(x) Valeur absolue de X |X|
Floor(x) Arrondir en moins Int(x)
Ceil(x) Arrondir en plus
Fmod(x, y) Reste rationnel de X/Y (même signe Pour x différent de 0
que X)
Tableau .14 Fonctions arithmétiques
VII. Les conversions de type
VII.1 Les conversions de type automatiques
 Calculs et affectations
Si un opérateur a des opérandes de différents types, les valeurs des opérandes
sont converties automatiquement dans un type commun.

13
Cours Algorithme et Programmation 2024-2025

Ces manipulations implicites convertissent en général des types plus 'petits' en des types
plus 'larges'; de cette façon on ne perd pas en précision.
Lors d'une affectation, la donnée à droite du signe d'égalité est convertie dans le type à
gauche du signe d'égalité. Dans ce cas, il peut y avoir perte de précision si le type de la
destination est plus faible que celui de la source.
Exemple : Considérons le calcul suivant:
int I = 8;
float X = 12.5;
double Y;
Y = I * X;
Pour pouvoir être multiplié avec X, la valeur de I est convertie en float (le type le plus large
des deux). Le résultat de la multiplication est du type float, mais avant d'être affecté a Y, il est
converti en double. Nous obtenons comme résultat: Y = 100.00
 Appels de fonctions
Lors de l'appel d'une fonction, les paramètres sont automatiquement convertis dans les types
déclarés dans la définition de la fonction.
Exemple : pour les expressions suivantes, nous assistons à trois conversions automatiques:
int A = 200;
int RES;
RES = pow(A, 2);
A l'appel de la fonction pow, la valeur de A et la constante 2 sont converties en double, parce
que pow est définie pour des données de ce type. Le résultat (type double) retourné par pow
doit être converti en int avant d'être affecté à RES.
 Règles de conversion automatique
Conversions automatiques lors d'une opération avec,
(R1) opération avec deux entiers:
D'abord, les types char et short sont convertis en int. Ensuite, l'ordinateur choisit le plus
large des deux types dans l'échelle suivante: int, unsigned int, long, unsigned long
(R2) opération avec un entier et un rationnel:
Le type entier est converti dans le type du rationnel.
(R3) opération avec deux rationnels:
L'ordinateur choisit le plus large des deux types selon l'échelle suivante: float, double, long
double
(4) opération avec affectations et opérateurs d'affectation:
Lors d'une affectation, le résultat est toujours converti dans le type de la destination. Si ce
type est plus faible, il peut y avoir une perte de précision.
Exemple : Observons les conversions nécessaires lors d'une simple division:
int X;
float A=12.48;
char B=4;

14
Cours Algorithme et Programmation 2024-2025

X=A/B;
B est converti en float (règle 2). Le résultat de la division est du type float (valeur 3.12) et
sera converti en int avant d'être affecté à X (règle 4), ce qui conduit au résultat X=3.
Remarque : le dépassement de capacité entraîne une perte de précision.
Exemple : unsigned int A=70000 ;
/* la valeur de A sera : 70000 mod 65536=4464*/
VII.2 Les conversions de type forcées (casting)
Il est possible de convertir explicitement une valeur en un type quelconque en forçant la
transformation à l'aide de la syntaxe: (<Type>) <Expression>
Exemple : Nous divisons deux variables du type entier. Pour avoir plus de précision, nous
voulons avoir un résultat de type rationnel. Pour ce faire, nous convertissons l'une des deux
opérandes en float. Automatiquement C convertira l'autre opérande en float et effectuera une
division rationnelle:
int A=3;
int B=4;
float C;
C = (float)A/B;
La valeur de A est explicitement convertie en float. La valeur de B est automatiquement
convertie en float (règle 2). Le résultat de la division (type rationnel, valeur 0.75) est affecté
à C.
Résultat: C=0.75
Attention !
Les contenus de A et de B restent inchangés; seulement les valeurs utilisées dans les calculs
sont converties !

15
Cours Algorithme et Programmation 2024-2025

Chapitre 3:

Lecture et écriture de données

- Ecriture formatée de donnée

- Lecture formatée de données
- La macro putchar
- La macro getchar

16
Cours Algorithme et Programmation 2024-2025

I. Écriture formatée de données

I.1. La fonction printf()
La fonction printf est utilisée pour transférer du texte, des valeurs de variables ou des
résultats d'expressions vers le fichier de sortie standard stdout (par défaut l'écran).
Ecriture formatée en C
printf("<format>",<Expr1>,<Expr2>, ... ) ;
"<format>" : format de représentation
<Expr1>,... : variables et expressions dont les valeurs sont à représenter
La partie "<format>" est en fait une chaîne de caractères qui peut contenir:
* du texte
* des séquences d'échappement
* des spécificateurs de format
Remarques :
¤ Les spécificateurs de format indiquent la manière dont les valeurs des expressions
<Expr1 .. Expr N> sont imprimées.
¤ La partie "<format>" contient exactement un spécificateur de format pour chaque
expression <Expr1.. Expr N>.
¤ Les spécificateurs de format commencent toujours par le symbole % et se terminent
par un ou deux caractères qui indiquent le format d'impression.
Exemple 1
La suite d'instructions:
int A = 1234;
int B = 567;
printf("%i fois %i est %li\n", A, B, (long)A*B);
Affichent sur l'écran:
1234 fois 567 est 699678
Les arguments de printf sont
- la partie format "%d fois %d est %ld"
- la variable A, la variable B et l'expression (long)A*B.
Le 1er spécificateur (%i) indique que la valeur de A sera imprimée comme entier relatif :
1234
Le 2eme spécificateur (%i) indique que la valeur de B sera imprimée comme entier relatif :
567
Le 3eme spécificateur (%li) indique que la valeur de (long)A*B sera imprimée comme entier
relatif long :  699678
Exemple 2
La suite d'instructions:
char B = 'A';
printf("Le caractère %c a le code %i !\n", B, B);

17
Cours Algorithme et Programmation 2024-2025

afficher sur l'écran: Le caractère A a le code 65 !

La valeur de B est donc affichée sous deux formats différents:
%c comme caractère: A
%d comme entier relatif: 65
65 est le code ASCII de la lettre A.
I.2 Spécificateurs de format pour printf
SYMBOLE TYPE IMPRESSION COMME

%d ou %i int entier relatif

%u int entier naturel (unsigned)
%o int entier exprimé en octal
%x int entier exprimé en hexadécimal
%c int caractère
%f double rationnel en notation décimale
%e double rationnel en notation scientifique
%s char* chaîne de caractères
Tableau .15 Spécificateurs de format printf

I.2.1. Arguments du type long

Les spécificateurs %d, %i, %u, %o, %x peuvent seulement représenter des valeurs du type
int ou unsigned int. Une valeur trop grande pour être codée dans deux octets est coupée sans
avertissement si nous utilisons %d.
Pour pouvoir traiter correctement les arguments du type long, il faut utiliser les spécificateurs
%ld, %li, %lu, %lo, %lx.
Exemple
long N = 1500000;
Printf("%ld, %lx", N, N); ==> 1500000, 16e360
I.2.2. Arguments rationnels
Les spécificateurs %f et %e peuvent être utilisés pour représenter des arguments du type
float ou double. La mantisse des nombres représentés par %e contient exactement un chiffre
(non nul) devant le point décimal. Cette représentation s'appelle la notation scientifique des
rationnels.
Pour pouvoir traiter correctement les arguments du type long, il faut utiliser les spécificateurs
%Lf et %Le.
Exemple
float N = 12.1234;
double M = 12.123456789;
long double P = 15.5;
printf("%f", N); ==> 12.123400

18
Cours Algorithme et Programmation 2024-2025

printf("%f", M); ==> 12.123457

printf("%e", N); ==> 1.212340e+01
printf("%e", M); ==> 1.212346e+01
printf("%Le", P); ==> 1.550000e+01
I.2.3. Largeur minimale pour les entiers
Pour les entiers, nous pouvons indiquer la largeur minimale de la valeur à afficher. Dans le
champ ainsi réservé, les nombres sont justifiés à droite.
Exemples
printf("%4d", 123); ==> ^123
printf("%4d", 1234); ==> 1234
printf("%4d", 12345); ==> 12345
printf("%4u", 0); ==> ^^^0
printf("%4X", 123); ==> ^^7B
printf("%4x", 123); ==> ^^7b
I.2.4. Largeur minimale et précision pour les rationnels
Pour les rationnels, nous pouvons indiquer la largeur minimale de la valeur à afficher et la
précision du nombre à afficher. La précision par défaut est fixée à six décimales. Les
positions décimales sont arrondies à la valeur la plus proche.
Exemples
printf("%f", 100.123); ==> 100.123000
printf("%12f", 100.123); ==> ^^100.123000
printf("%.2f", 100.123); ==> 100.12
printf("%5.0f", 100.123); ==> ^^100
printf("%10.3f", 100.123); ==> ^^^100.123
printf("%.4f", 1.23456); ==> 1.2346
printf("%.2f", 1.23456); ==> 1.23
II. Lecture formatée de données
II.1 La fonction scanf()
La fonction scanf est la fonction symétrique à printf; elle nous offre pratiquement les mêmes
conversions que printf, mais en sens inverse.
Lecture formatée en C
scanf("<format>",<AdrVar1>,<AdrVar2>, ...) ;
"<format>" : format de lecture des données
<AdrVar1>,... : adresses des variables auxquelles les données seront attribuées
¤ La fonction scanf reçoit ses données à partir du fichier d'entrée standard stdin (par
défaut le clavier).
¤ La chaîne de format détermine comment les données reçues doivent être interprétées.

19
Cours Algorithme et Programmation 2024-2025

¤ Les données reçues correctement sont mémorisées successivement aux adresses

indiquées par <AdrVar1>,... .
¤ L'adresse d'une variable est indiquée par le nom de la variable précédé du signe &.
Exemple
La suite d'instructions:
int JOUR, MOIS, ANNEE;
scanf("%i %i %i", &JOUR, &MOIS, &ANNEE);
lit trois entiers relatifs, séparés par des espaces, tabulations ou interlignes. Les valeurs sont
attribuées respectivement aux trois variables JOUR, MOIS et ANNEE.
scanf retourne comme résultat le nombre de données correctement reçues (type int).
II.2 Spécificateurs de format pour scanf
SYMBOLE LECTURE D'UN(E) TYPE

%d ou %i entier relatif int*

%u entier naturel (unsigned) int*
%o entier exprimé en octal int*
%b entier exprimé en hexadécimal int*
%c caractère char*
%s chaîne de caractères char*
%f ou %e rationnel en notation décimale ou exponentielle (scientifique) float*
Tableau .16 Spécificateurs de format scanf
Le symbole * indique que l'argument n'est pas une variable, mais l'adresse d'une variable de
ce type (c.-à-d.: un pointeur sur une variable).
II.2.1. Le type long
Si nous voulons lire une donnée du type long, nous devons utiliser les spécificateurs %ld,
%li, %lu, %lo, %lx. (Sinon, le nombre est simplement coupé à la taille de int).
II.2.2. Le type double
Si nous voulons lire une donnée du type double, nous devons utiliser les spécificateurs %le
ou %lf.
II.2.3. Le type long double
Si nous voulons lire une donnée du type long double, nous devons utiliser les spécificateurs
%Le ou %Lf.
II.2.4. Indication de la largeur maximale
Pour tous les spécificateurs, nous pouvons indiquer la largeur maximale du champ à évaluer
pour une donnée. Les chiffres qui passent au-delà du champ défini sont attribués à la
prochaine variable qui sera lue !
Exemple
Soient les instructions:
int A,B;

20
Cours Algorithme et Programmation 2024-2025

scanf("%4d %2d", &A, &B);

Si nous entrons le nombre 1234567, nous obtiendrons les affectations suivantes:
A=1234
B=56
le chiffre 7 sera gardé pour la prochaine instruction de lecture.
II.2.5. Les signes d'espacement
Lors de l'entrée des données, une suite de signes d'espacement (espaces, tabulateurs,
interlignes) est évaluée comme un seul espace. Dans la chaîne de format, les symboles \t, \n,
\r ont le même effet qu'un simple espace.
Exemple
Pour la suite d'instructions
int JOUR, MOIS, ANNEE;
scanf("%d %d %d", &JOUR, &MOIS, &ANNEE);
les entrées suivantes sont correctes et équivalentes:
12 4 1980 ou 12 004 1980 ou
12
4
1980
II.2.6. Formats 'spéciaux'
Si la chaîne de format contient aussi d'autres caractères que des signes d'espacement, alors ces
symboles doivent être introduits exactement dans l'ordre indiqué.
Exemple
La suite d'instructions
int JOUR, MOIS, ANNEE;
scanf("%i/%i/%i", &JOUR, &MOIS, &ANNEE);
accepte les entrées: rejette les entrées:
12/4/1980 12 4 1980
12/04/01980 12 /4 /1980
II.2.7. Nombre de valeurs lues
Lors de l'évaluation des données, scanf s'arrête si la chaîne de format a été travaillée jusqu'à la
fin ou si une donnée ne correspond pas au format indiqué. scanf retourne comme résultat le
nombre d'arguments correctement reçus et affectés.

21
Cours Algorithme et Programmation 2024-2025

Exemple
La suite d'instructions
int JOUR, MOIS, ANNEE, RECU;
RECU = scanf("%i %i %i", &JOUR, &MOIS, &ANNEE);
réagit de la façon suivante ( - valeur indéfinie):
Introduit: RECU JOUR MOIS ANNEE
12 4 1980 ==> 3 12 4 1980
12/4/1980 ==> 1 12 - -
12.4 1980 ==> 1 12 - -
12 4 19.80 ==> 3 12 4 19
III. la macro putchar
La fonction putchar (c) joue le même rôle que printf(“%c” ,c) ;
IV. la macro getchar.
L’expression c=getchar() joue le même rôle que scanf(“%c” ,&c) ;
Exemples
char c ;
c=getchar() ; /*lecture d’une lettre c*/
putchar (c) ; /*afficher la lettre c*/
getchar et putchar sont deux macros de la biblilothèque <stdio.h>.

22
Cours Algorithme et Programmation 2024-2025

Chapitre 4:

LA STRUCTURE ALTERNATIVE

- if - else
- if sans else
- if-else if-…-else
- Switch
- L’opérateur conditionnel

23
Cours Algorithme et Programmation 2024-2025

I. If-else

Algorithmique C
si (<expression>) if ( <expression> )
alors <bloc d'instructions 1>
<bloc d'instructions 1> else
sinon <bloc d'instructions 2>
<bloc d'instructions 2>
Fin si
 Si l'<expression> a la valeur logique vrai (  0 ), alors le <bloc d'instructions 1> est
exécuté. Sinon le <bloc d'instructions 2> est exécuté.
La partie <bloc d'instructions> peut désigner :
 Plusieurs instructions comprises entre accolades,
 Une seule instruction terminée par un point-virgule.
Exemple 1 Exemple 2
Algorithmique C Algorithmique C
si (a > b) si (a > b)
alors alors
max ← a aide ← A
sinon A←C
max ← b C← aide
Sinon
finsi
Aide ← B
B←C
C ← aide
Finsi

II. if sans else

if ( <expression> )
<bloc d'instructions>

La partie else est facultative.

Attention !
Comme la partie else est optionnelle, les expressions contenant plusieurs structures if
et if - else peuvent mener à des confusions.
Algorithmique C
si (N>0) if ( <expression> )
alors <bloc d'instructions 1>
si (A>B) else
alors <bloc d'instructions 2>
max ← A
sinon

24
Cours Algorithme et Programmation 2024-2025

max ← B
finsi
finsi
si (N>0)
alors
si (A>B)
alors
max ← A
finsi
sinon
max ← B
finsi
Par Convention
En C une partie else est toujours liée au dernier if qui ne possède pas de partie else.
Solution
Pour éviter des confusions et pour forcer une certaine interprétation d'une expression, il est
recommandé d'utiliser des accolades { }.
III. if-else if-…-else
En combinant plusieurs structures if - else en une expression nous obtenons une structure qui
est très courante pour prendre des décisions entre plusieurs alternatives:
if ( <expr1> )
<bloc1>
else if (<expr2>)
<bloc2>
else if (<expr3>)
<bloc3>
…………………
else if (<exprN>)
<blocN>
else
<blocN+1>

Les expressions <expr1> ... <exprN> sont évaluées du haut vers le bas jusqu'à ce que l'une
d'elles soit différente de zéro. Le bloc d'instructions y lié est alors exécuté et le traitement de
la commande est terminé.
Algorithmique C
Algorithme grand
A,B : entier
Début
Ecrire (“entrez deux nombres entiers :”)
Lire (A,B)
Si (A>B)
Alors

25
Cours Algorithme et Programmation 2024-2025

Ecrire (A,“est plus grand que”,B)

Sinon
Si (A<B)
Alors
Ecrire (A,“est plus petit que”,B)
Sinon
Ecrire (A,“est égal à ”,B)
Finsi
Finsi
Fin
La dernière partie else traite le cas où aucune des conditions n'a été remplie. Elle est
optionnelle, mais elle peut être utilisée très confortablement pour détecter des erreurs.
IV. Switch
Algorithmique C
Selon que (Selecteur) Switch (Selecteur)
Constante_1 : {
<bloc d’instructions_1> Case constante_1 :
Constante_2 : <bloc d’instructions_1>
<bloc d’instructions_1> Break ;
…………. ………..
Constante_n : Case constante_n :
<bloc d’instructions_n> <bloc d’instructions_n>
Sinon Break ;
<bloc d’instructions_n+1> Default :
Fin selon <bloc d’instructions_n+1>
}
L’instruction break permet de sortir de switch
V. L’opérateur conditionnel
Le langage C possède une paire d'opérateurs un peu exotiques qui peut être utilisée comme
alternative à if - else et qui a l'avantage de pouvoir être intégrée dans une expression:
<expr1> ? <expr2> : <expr3> ;

 Si <expr1> fournit une valeur différente de zéro, alors la valeur de <expr2> est fournie
comme résultat
 Si <expr1> fournit la valeur zéro, alors la valeur de <expr3> est fournie comme
résultat
Exemple
La suite d'instructions

if (A>B)
MAX=A; peut être remplacée par: MAX = (A > B) ? A : B;
else
MAX=B;

26
Cours Algorithme et Programmation 2024-2025

Chapitre 5:

LA STRUCTURE REPETITIVE

- do – while (Répéter … jusqu’à)

- while (Tant que)
- for (pour)
- Application

27
Cours Algorithme et Programmation 2024-2025

I. do – while (Répéter … jusqu’à)

Algorithmique C
Répéter do
<bloc d’instructions> <bloc d’instructions>
Jusqu’à (<expression>) While (! <expression>)
La condition d’arrêt <expression> dans l’algorithme sera inverse logiquement en C.
 do - while évalue la condition après avoir exécuté le bloc d'instructions. Ainsi le bloc
d'instructions est exécuté au moins une fois.
La partie <bloc d’instructions> peut désigner :
 plusieurs instructions comprises entre accolades,
 une seule instruction terminée par un point-virgule.
Exemple :
L’algorithme suivant permet de saisir un entier positif N et de calculer sa racine carrée.
Algorithmique C
Algorithme RACINE
N : entier
Début
Répéter
écrire (“Entrer un nombre positif”)
lire (N)
jusqu’à (N>=0)
écrire(“la racine carrée
de”,N,“est”,racine_carrée(N))
fin
II. While (Tant que)
Algorithmique C
Tant que (<expression>) While ( <expression>)
Faire <bloc d’instructions>
<bloc d’instructions>
Fin faire
while évalue la condition avant d’exécuter le bloc d’instruction. Ainsi, le <bloc
d’instruction> est exécuté zéro ou plusieurs fois.
Exemple :
L’algorithme suivant permet de cumuler des nombres impairs jusqu’à un nombre donné.
Algorithmique C
Algorithme somme_impair
Impair, somme, dernier : entier
Début

28
Cours Algorithme et Programmation 2024-2025

Impair 1
Somme 0
écrire(“Donner le dernier nombre impair”)
lire(dernier)
tan que (impair<=dernier)
faire
somme somme+impair
impair impair+2
fin faire
écrire(“La somme =”, sommme)
fin
III. For (pour)
Algorithmique C
Pour compteur de VI à VF For (compteur=VI ; compteur<=VF ;
Faire compteur++)
<bloc d’instruction> <bloc d’instruction>
Fin faire
Pour compteur de VI à VF par pas (-1) For (compteur=VI ; compteur>=VF ;
Faire compteur--)
<bloc d’instruction> <bloc d’instruction>
Fin faire
Pour compteur de VI à VF par pas de (K) For (compteur=VI ; compteur>=VF ;
Faire compteur+=K)
<bloc d’instruction> <bloc d’instruction>
Fin faire

VI : valeur initiale ; valeur finale ; K : entier quelconque

En général, la structure de la boucle for se présente comme suit :
For (<expr1> ; <expr2> ; <expr3>)
<bloc d’instruction>

<expr1> est évalué une fois avant le passage de boucle. Elle est utilisée pour initialiser les
données de la boucle.
<expr2> est évalué avant chaque passage de la boucle. Elle est utilisée pour décider si la
boucle est répétée ou non.
<expr3> est évaluée à la fin de chaque passage de la boucle. Elle est utilisée pour réinitialiser
les données de la boucle.
 Exemple
L’algorithme suivant permet de calculer la somme S des n premiers termes de la « série
harmonique » définie comme suit :
S=1+ 1 + 1 + 1 + ……. + 1
2 3 4 n
n doit être strictement positif.

29
Cours Algorithme et Programmation 2024-2025

Algorithmique C
Algorithme suite
i,n :entier
s : réel
Début
S0
Répéter
écrire(“combien de termes : ”)
lire(n)
jusqu’à (n  1 )
pour i de 1 à n
faire
SS+ 1
i
fin pour
écrire(“La somme des”, n, “premiers termes
est ”, S)
Fin

IV. Application
Ecrire un programme qui détermine si un nombre de deux chiffres est parfait. Un nombre est
parfait s’il est égal à la somme de ses diviseurs stricts.
Par exemple, 28 est parfait car 28= 1+2+4+7+14.
Algorithmique C
Algorithme parfait
I,nb,s :entier
Début
Répéter
écrire(“donner un nombre de deux chiffres :”
lire(nb)
jusqu’à ((nb>9) et (nb<=99))
s0
pour i de 1 à nb/2 faire
si(nb mod i =0) alors
ss+i
fin si
fin pour
si (nb=s) alors
écrire(nb, “est parfait”)
sinon
écrire(nb, “n’est pas parfait”)
fin si
fin

30
Cours Algorithme et Programmation 2024-2025

Chapitre 6:

LES TABLEAUX :

Vecteurs et Matrices

- les tableaux à une dimension : les vecteurs

- les tableaux à deux dimensions: les matrices

31
Cours Algorithme et Programmation 2024-2025

I. Les tableaux à une dimension : les vecteurs

1. Déclaration
<TypeSimple> <NomTableau>[<Dimension>] ;
 Exemples
int A[5] ; float B[6] ; char D[20];
2. Initialisation
int A[5] = {10, 20, 30, 40, 50};
float B[4] = {-1.05, 3.33, 87e-5, -12.3E4};
Il faut évidemment veiller à ce que le nombre de valeurs dans la liste corresponde à la
dimension du tableau. Si la liste ne contient pas assez de valeurs pour toutes les composantes,
les composantes restantes sont initialisées par zéro.
 Remarque
Si la dimension n'est pas indiquée explicitement lors de l'initialisation, alors l'ordinateur
réserve automatiquement le nombre d'octets nécessaires.
 Exemples
int A[] = {10, 20, 30, 40, 50}; => réservation de 5*sizeof(int) octets (dans notre cas: 10
octets)
float B[] = {-1.05, 3.33, 87e-5, -12.3E4}; => réservation de 4*sizeof(float) octets (dans notre
cas: 16 octets)
3. Mémorisation
En C, le nom d'un tableau est le représentant de l'adresse du premier élément du tableau. Les
adresses des autres composantes sont calculées (automatiquement) relativement à cette
adresse.
 Exemple
short A[5] = {1200, 2300, 3400, 4500, 5600};

Si un tableau est formé de N composantes et si une composante a besoin de M octets en

mémoire, alors le tableau occupera de N*M octets.
4. Accès aux composantes

Le premier élément : A[0]=1200

Le deuxième élément : A[1]=2300
…
Le cinquième élément : A[4]=5600

32
Cours Algorithme et Programmation 2024-2025

 Conclusion :
Considérons un tableau T de dimension N:
- l'accès au premier élément du tableau se fait par T[0]
- l'accès au dernier élément du tableau se fait par T[N-1]
5. Remplissage d’un vecteur
Void main ()
{
int A[5] ;
int i ; // compteur
printf(“remplir le tableaux”) ;
for(i=0 ; i<5 ; i++)
scanf(“%d\n”,&A[i]);
}
6. Affichage d’un vecteur
Void main ()
{
int A[5]={10,20,30,40,50} ;
int i ; // compteur
printf(“remplir le tableaux”) ;
for(i=0 ; i<5 ; i++)
printf(“%d\n”,A[i]) ;
}

II. Les tableaux à deux dimensions : les matrices

En C, un tableau à deux dimensions A est à interpréter comme un tableau (uni-dimensionnel)
de dimension L (ligne) dont chaque composante est un tableau (uni-dimensionnel) de
dimension C (colonne).
1. Déclaration
<TypeSimple> <NomTableau>[<DimLigne>][<DimCol>] ;
 Exemples
int A[3][5] ; float B[3][2] ; char D[15][40];
2. Initialisation
int A[3][10] ={{ 0,10,20,30,40}, {15,16,17,18,19}, {56,67,78,89,90}};
float B[3][2] = {{-1.05, -1.10 }, {86e-5, 87e-5 }, {-12.5E4, -12.3E4}};
Lors de l'initialisation, les valeurs sont affectées ligne par ligne en passant de gauche à droite.
Nous ne devons pas nécessairement indiquer toutes les valeurs: Les valeurs manquantes
seront initialisées par zéro. Il est cependant défendu d'indiquer trop de valeurs pour un
tableau.

33
Cours Algorithme et Programmation 2024-2025

 Remarque
1. Si le nombre de lignes L n'est pas indiqué explicitement lors de l'initialisation,
l'ordinateur réserve automatiquement le nombre d'octets nécessaires.
 Exemple
int A[][10] = {{ 0,10,20,30,40}, {10,11,12,13,14},{ 1,12,23,34,45}};
i. Réservation de 3*10*2 = 60 octets
2. Le nombre de colonne doit être toujours indiqué lors de l’initialisation.
3. Mémorisation
Comme pour les tableaux à une dimension, le nom d’un tableau représente l’adresse du
premier élément du tableau (c.-à-d. l'adresse de la première ligne du tableau). Les
composantes d'un tableau à deux dimensions sont stockées ligne par ligne dans la mémoire.
 Exemple
short A[3][2] = {{1, 2 }, {10, 20 }, {100, 200}};

Un tableau de dimensions L et C, formé de composantes dont chacune a besoin de M octets,

occupera L*C*M octets en mémoire.

4. Accès aux composantes

<NomTableau>[<Ligne>][<Colonne>]
 Exemples
int A[3][5]= {{0,10,20,30,40}, {10,11,12,13,14},{ 1,12,23,34,45}};
A[0][0]=0 A[0][1]=10 … A[0][0]=0
A[1][0]=10 A[1][1]=11 .... A[1][4]=14
A[2][0]=1 A[2][1]=12 … A[2][4]=45
 Conclusion :
La composante de la Nième ligne et Mième colonne est notée: A[N-1][M-1]
5. Remplissage d’une matrice
Void main ()
{
int A[3][5] ;
int i,j ; // compteur
printf(“remplir la matrice”) ;
for(i=0 ; i<3 ; i++)
for(j=0 ; j<5 ; j++)
scanf(“%d\n”,&A[i][j]);
}

34
Cours Algorithme et Programmation 2024-2025

6. Affichage d’une matrice

Void main ()
{
int A[3][5]= {{0,10,20,30,40}, {10,11,12,13,14},{ 1,12,23,34,45}};
int i,j ; // compteur
printf(“remplir la matrice”) ;
for(i=0 ; i<3 ; i++)
{
for(j=0 ; j<5 ; j++)

printf(“%d\n”,A[i][j]) ;
}

35