Support langage C

Chapitre I. ELEMENTS DU LANGAGE C

1. Introduction
Le langage C a été conçu afin de réécrire de façon portable et en langage évolué le système
d'exploitation UNIX. En 1972, Dennis Ritchie, s'inspirant d'Algol 60 et du langage B de Ken
Thompson, donne ainsi naissance au langage C. En 1973, UNIX est réécrit en langage C par D.
Ritchie et K. Thompson.

Bien que le langage C n'ai pas été développé à la base pour concurrencer les langages existant à
l'époque (Fortran et Pascal, par exemple), le succès qu'a connu UNIX, notamment auprès des
universités, a fortement contribué à sa popularité. Il s'est vite imposé comme LE langage de
programmation par excellence d'UNIX.

En 1978, Brian Kernighan et Dennis Ritchie publient une définition du langage C qui restera
pour longtemps la norme de référence.

La plupart des fonctionnalités sont réalisées à partir de la librairie standard. Le C est

sémantiquement proche du matériel : les structures de données sont exprimées en fonction de
l'architecture de la machine (mot, registre, adresse, ...) Ainsi les programmes ont pour avantage
d'être efficaces, le code généré est rapide et compact.

2. Mise en oeuvre d’un programme C

La réalisation d'un programme commence par la traduction en C des algorithmes. Cette phase
de rédaction se fait à l'aide d'un éditeur de texte. Le programme source ainsi rédigé est ensuite
traité par le préprocesseur qui, suivant les directives de compilation, substitue des symboles,
inclut des fichiers sources etc... Le fichier source d'origine est retravaillé et présenté au
compilateur.

FSM Page 1
 Support langage C

Le compilateur examine chaque ligne, vérifie la syntaxe et génère un code intermédiaire.

Il reste alors à rassembler les codes intermédiaires (dans le cas où le programme est découpé en
plusieurs fichiers sources) et à les lier aux diverses librairies. C'est le rôle de l'éditeur de liens
(linker) qui produit le code exécutable du programme.

3. Structure d’un programme C

Un programme C se présente de la façon suivante :

Déclarations des bibliothèques

main() /* Programme principale */
{ /* Début du programme */
Déclarations de variables internes ; /* Corps du programme */
Instructions ;
} /* Fin du programme */

Le langage C distingue les minuscules, des majuscules. Les mots réservés du langage C
doivent être écrits en minuscules.

Le langage C possède assez peu d'instructions, il fait par contre appel à des bibliothèques,
fournies avec le compilateur.

Exemples : math.h : bibliothèque de fonctions mathématiques

stdio.h : bibliothèque d'entrées/sorties standard (Lire, Ecrire)

FSM Page 2
 Support langage C

4. Les différents types de variables

4.1. Les entiers

Le langage C distingue plusieurs types d'entiers :

Type Description Taille mémoire
int entier standard signé 4 octets : - 231 ≤ n ≤231-1
unsigned int entier positif 4 octets : 0 ≤ n ≤ 232
short entier court signé 2 octets : - 215 ≤ n ≤ 215-1
unsigned short entier court non signé 2 octets : 0 ≤≤n ≤ 216
char caractère signé 1 octet : - 27 ≤≤n ≤ 27-1
unsigned char caractère non signé 1 octet : 0 ≤n ≤ 28

Numération: En décimal les nombres s'écrivent tels que, précédés de 0x en hexadécimal.

Exemple: 127 (décimal) = 0x7f (hexadécimal).

Remarque: En langage C, le type char est un cas particulier du type entier : un caractère est un
entier de 8 bits. Les caractères alphanumériques s'écrivent entre ‘ ‘.

Exemples:
Le caractère 'a' a pour valeur 97 (son code ASCII).
Le caractère 'A' a pour valeur 65 (son code ASCII).

4.2. Les réels

Un réel est composé : d'un signe, d'une mantisse et d'un exposant. Le langage C distingue 3
types de réels:
Type Description Taille mémoire
Float réel standard 4 octets
Double réel double précision 8 octets
réel quadruple
long double 16 octets
précision

Remarque : L'opérateur sizeof(type) renvoie le nombre d'octets réservés en mémoire pour

chaque type d'objet.
Exemples : n = sizeof(char); /* n = 1 */
m = sizeof(int); /* m = 4 */

5. Les constantes

FSM Page 3
 Support langage C

Une constante est une valeur qui apparaît littéralement dans le code source d'un programme, le
type de la constante étant déterminée par la façon dont la constante est écrit.

Le langage C autorise 2 méthodes pour définir les constantes.

1ère méthode: déclaration d'une variable, dont la valeur sera constante pour tout le programme.
Exemple : main()
{
const float PI = 3.14159;
float perimetre, rayon = 8.7;
perimetre = 2 * rayon * PI;
....
}

2ème méthode: définition d'un symbole à l'aide de la directive de compilation #define.

Exemple : #define PI = 3.14159
main()
{
float perimetre, rayon = 8.7;
perimetre = 2 * rayon * PI;
....
}

Quelques constants caractères :

\n interligne \r retour charriot
\t tabulation horizontale \f saut de page
\v tabulation verticale \a signal d'alerte (bip sonore)
\b retour arrière

6. Les initialisations
Le langage C permet l'initialisation des variables dans la zone des déclarations :

char c; ≡ char c = 'A';

c = 'A';

int i; ≡ int i = 50;

i = 50;

7. Les opérateurs

Opérateurs arithmétiques sur les réels : + - * / avec la hiérarchie habituelle.

Opérateurs arithmétiques sur les entiers : + - * / (quotient de la division) % (reste de la

division) avec la hiérarchie habituelle.
Exemple : char c, d;
c = 'G';

FSM Page 4
 Support langage C

d = c + 'a' - 'A';

Les caractères sont des entiers sur 8 bits, on peut donc effectuer des opérations. Dans
l’exemple ci-dessus, on transforme la lettre majuscule G en la lettre minuscule g.

Opérateurs relationnels :

> strictement supérieur

>= supérieur ou égal
< strictement inférieur
<= inférieur ou égal
== égal
!= différent

Attention à ne pas confondre l'opérateur de test d'égalité "==" avec l'opérateur d'affection "=".
Opérateurs logiques booléens :

&& ET logique
|| OU logique
! négation logique

Opérateurs logiques sur les entiers bit à bit :

& ET
| OU
^ OU exclusif
~ Complément à un
<< Décalage à gauche
>> Décalage à gauche

Exemple 1:
n = 23 ; /* n = 00010111 en binaire */
p = n << 2; /* p = n décalé de 2 bits à gauche = 01011100 = 92 */
q = n >> 1; /* q = n décalé de 1 bit à droite = 00001011 = 11 */

Exemple 2:
Considérons par exemple les entiers a =77 et b = 23 de type unsigned char (i.e. 8 bits). En base
2 il s'écrivent respectivement 01001101 et 00010111.

Valeur
Expression Binaire Décimale
a 01001101 77

FSM Page 5
 Support langage C

b 00010111 23
a&b 00000101 5
a|b 01011111 95
a^b 01011010 90
~a 10110010 178
b << 2 01011100 92 multiplication par 4
b << 5 11100000 224 ce qui dépasse disparaît
b >> 1 00001011 11 division entière par 2

8. Incrémentation et décrémentation
Le langage C autorise des écritures simplifiées pour l'incrémentation et la décrémentation de
variables :

i = i+1; ≡ i++;
i = i-1; ≡ i--;

Le langage C autorise des écritures simplifiées lorsqu'une même variable est utilisée de chaque
côté du signe = d'une affectation. Ces écritures sont à éviter lorsque l'on débute l'étude du
langage C car elles nuisent à la lisibilité du programme.

a= a+b; ≡ a+= b;
a= a-b; ≡ a-= b;
a= a & b; ≡ a&= b;
a= a / b; ≡ a/= b;

9. Les conversions de types

L'opérateur de conversion de type, appelée cast ( ), permet de modifier explicitement le type
d'un objet. On écrit : (type) objet

Exemple :
int i = 3, j = 2;
float x;
x = (float) i/j; ==> x = 1.5

int i=0x1234, j ;
float s, r=86.7 ;
j = (int) r ;
s = (float) i ;

10. Quelques fonctions

sqrt : racine carré d’un entier ou d’un réel, bibliothèque math.h.

FSM Page 6
 Support langage C

Exemple : sqrt(16) = 4

floor et ceil : arrondissement d’un réel, bibliothèque math.h.

Exemple : floor(2.3) = 2
floor(4.7) = 4
ceil (2.3) = 3
ceil (4.7) = 5

pow : la puissance nième de x (xn) , bibliothèque math.h.

Exemple : pow(2, 3) = 23 = 8
pow(5, 4) = 54 = 625

Rq : La fonction sqr (carré) n’existe pas dans le langage C.

Mise en oeuvre d’un programme C

Code ASCII :

HE DE CH HE DE CH HE DE CH HE DE CH
X C R X C R X C R X C R
NU
00 0 20 32 SP 40 64 @ 60 96 `
L
SO
01 1 21 33 ! 41 65 A 61 97 a
H
ST
02 2 22 34 " 42 66 B 62 98 b
X
ET
03 3 23 35 # 43 67 C 63 99 c
X
EO
04 4 24 36 $ 44 68 D 64 100 d
T
EN
05 5 25 37 % 45 69 E 65 101 e
Q
06 6 AC 26 38 & 46 70 F 66 102 f

FSM Page 7
 Support langage C

K
BE
07 7 27 39 ' 47 71 G 67 103 g
L
08 8 BS 28 40 ( 48 72 H 68 104 h
09 9 HT 29 41 ) 49 73 I 69 105 i
0A 10 LF 2A 42 * 4A 74 J 6A 106 j
0B 11 VT 2B 43 + 4B 75 K 6B 107 k
0C 12 FF 2C 44 , 4C 76 L 6C 108 l
0D 13 CR 2D 45  4D 77 M 6D 109 m
0E 14 SO 2E 46 . 4E 78 N 6E 110 n
0F 15 SI 2F 47 / 4F 79 O 6F 111 o
DL
10 16 30 48 0 50 80 P 70 112 p
E
DC
11 17 31 49 1 51 81 Q 71 113 q
1
DC
12 18 32 50 2 52 82 R 72 114 r
2
DC
13 19 33 51 3 53 83 S 73 115 s
3
DC
14 20 34 52 4 54 84 T 74 116 t
4
NA
15 21 35 53 5 55 85 U 75 117 u
K
SY
16 22 36 54 6 56 86 V 76 118 v
N
ET
17 23 37 55 7 57 87 W 77 119 w
B
CA
18 24 38 56 8 58 88 X 78 120 x
N
19 25 EM 39 57 9 59 89 Y 79 121 y
SU
1A 26 3A 58 : 5A 90 Z 7A 122 z
B
ES
1B 27 3B 59 ; 5B 91 [ 7B 123 {
C
1C 28 FS 3C 60 < 5C 92 \ 7C 124 |
1D 29 GS 3D 61 = 5D 93 ] 7D 125 }
1E 30 RS 3E 62 > 5E 94 ^ 7E 126 ~
DE
1F 31 US 3F 63 ? 5F 95 _ 7F 127
L

FSM Page 8
 Support langage C

Chapitre II. LES FONCTIONS D’AFFICHAGE ET DE SAISIE

1. Fonctions d’affichage

1.1. La fonction printf

Ce n'est pas une instruction du langage C, mais une fonction de la bibliothèque stdio.h.

Syntaxe :
printf( " chaine de caractère " , paramètres );

Exemple :
printf("La valeur de x est %d ", x );

Message Format Paramètre

Exemple : affichage d'un texte

printf("BONJOUR"); /* pas de retour à la ligne du curseur après l'affichage */

printf("BONJOUR\n"); /* affichage du texte, puis retour à la ligne du curseur */

Formats des variables :

%d, %i : int, short int

%u : unsigned int (entier non-signé)
%f : float
%lf : double
%e, %a, %g : float ou double
%c : caractère
%s : chaîne de caractères
%o : entier non-signé en Octal
%x : entier non-signé en Hexadécimal

Exemple :
#include <stdio.h>
#include <conio.h>
main()
{
char c;
c = 65; /* c = caractère alphanumérique ‘A’ (65 = code ASCII de ‘A’) */
printf("%d\n", c); /* affichage du code ASCII en décimal et retour à la ligne */
printf("%o\n", c); /* affichage du code ASCII en base huit et retour à la ligne */
printf("%x\n", c); /* affichage du code ASCII en hexadécimal et retour à la ligne */
printf("%c\n", c); /* affichage du caractère ‘A’ et retour à la ligne */
getch();
}

FSM Page 9
 Support langage C

Exemple :
Algorithmique C
Variables #include<stdio.h>
x, a, b : entier #include<conio.h>
r : réel
ch : caractère main()
Début {
x2 int x = 2, a = 47, b = 123 ;
r  3.57 float r = 3.57 ;
a  47 char ch = ‘m’ ;
ch  ‘m’
b  123 printf(" x = %d ", x);
écrire("x = ", x) printf(" r = %f ", r);
écrire("r = ", r) printf(" a = %d ", a);
écrire("a = ", a) printf(" ch = %c ", ch);
écrire("ch = ", ch) printf(" b = %d ", b);
écrire("b = ", b) getch();
Fin }

Affichage multiple de variables :

printf("%format1 %format2 .... %formatn", variable1, variable2, ..., variablen);

printf("x = %d , r = %f , a = %d , ch = %c et b = %d ", x , r , a , ch , b );

1.2. La fonction putchar

La fonction putchar permet d'afficher un caractère. Elle appartient à la bibliothèque stdio.h.

Exemple :
char c
putchar(c); ≡ printf("%c\n",c);

1.3. La fonction puts

La fonction puts permet d'afficher un texte. Elle appartient à la bibliothèque stdio.h.

Exemple :
puts("bonjour"); ≡ printf("bonjour\n");

2. Fonctions de saisie

2.1. La fonction getch

FSM Page 10
 Support langage C

La fonction getch, appartenant à la bibliothèque conio.h, permet la saisie clavier d'un caractère
alphanumérique. La saisie s'arrête dès que le caractère a été frappé.

On peut utiliser getch de deux façons: sans et avec retour de variable.

a) sans retour de variable au programme.

Exemple : printf("Pour continuer frapper une touche ");
getch();

b) avec retour de variable au programme.

Exemple : char alpha;
printf("Entrer un caractère");
alpha = getch();
printf("\nVoici ce caractère: %c", alpha);

2.2. La fonction scanf

La fonction scanf, appartenant à la bibliothèque stdio.h, permet la saisie clavier de n'importe

quel type de variable.

Les variables à saisir sont formatées, le nom de la variable est précédé du symbole & désignant
l'adresse de la variable.

La saisie s'arrête avec "RETURN" (c'est à dire LF, son code ASCII = 10 = 0x0A), les éléments
saisis s'affichent à l'écran. Tous les éléments saisis après un caractère d'espacement (espace,
tabulation) sont ignorés.

Syntaxe :
scanf( " format " , paramètres );

Exemple :
scanf(" %d ", &x );

Format Paramètre

Saisit de multiples de variables :

scanf("%format1 %format2 .... %formatn", &variable1, &variable2, ..., &variablen);

scanf("%d %f %d %c %d ", &x , &r , &a , &ch , &b );

Exemples : char alpha;

int i;
float r;
scanf("%c", &alpha); /* saisie d'un caractère */
scanf("%d", &i); /* saisie d'un entier en décimal */

FSM Page 11
 Support langage C

scanf("%x", &i); /* saisie d'un entier en hexadécimal */

scanf("%f", &r); /* saisie d'un réel */

Exemple : char alpha;

scanf("%d", &alpha);

Si l'utilisateur saisie 97 tout va bien, alpha devient le caractère dont le code ASCII vaut 97,
c.a.d. le caractère ‘a’. Par contre, si l'utilisateur saisie ‘a’, sa saisie est ignorée.

2.3. La fonction getchar

La fonction getchar permet la saisie d'un caractère (char). Elle appartient à la bibliothèque
stdio.h. Les deux écritures suivantes sont équivalentes :

char c; char c;
printf("entrer un caractère: "); printf("entrer un caractère: ");
scanf("%c", &c); c = getchar();

‘’’’’’’’

FSM Page 12
 Support langage C

Chapitre 3

Les instructions de branchements et

de boucles

On appelle instruction de contrôle toute instruction qui permet de contrôler le

fonctionnement d’un programme. Parmi les instructions de contrôle, on distingue les
instructions de branchement et les boucles. Les instructions de branchement permettent
de déterminer quelles instructions seront exécutées et dans quel ordre.

3.1 Les instructions de branchement conditionnel

3.1.1 L’instruction IF ... ELSE
Il s’agit de l’instruction :
Algorithmique Langage C
si (condition) if (expression)
alors {....; } /*bloc1
bloc1 d’instructions*/
d’instruction else
sinon {....; } /*bloc2
bloc2 d’instructions*/
Organigramme :
d’instruction
finSi

Le bloc ”sinon” est optionnel :

FSM Page 13
 Support langage C

Algorithmique Langage C
si (condition) if (expression)
alors {....; } /*bloc1
bloc1 d’instructions*/
d’instruction
organigramme
finSi
: Remarque :

Les {} ne sont pas nécessaires lorsque les blocs ne comportent qu’une seule instruction.

3.1.2 Les opérateurs logiques

Test d’égalité if (a==b) ”si a égal b”
Test de non égalité if (a! = b) ”si a différent de b”
Test de relation d’ordre if (a < b) if(a <= b) if(a > b) if(a
>= b) Test de ET logique if((expression1) &&
(expression2))
si l’expression1 et l’expression2 sont vraies
Test de OU logique if((expression1) || (expression2))
si l’expression1 ou l’expression2 est vraie
Test de NON logique if(!(expression))
si l’expression est
fausse

Exemple
Ecrire un programme qui permet d’afficher le maximum et le minimum de deux entiers
A et B saisie au clavier.
#include<stdio.h>
Void main()
{
int A, B, max,
min;
printf("Donner A:");
scanf("%d", &A);
printf("Donner B:");
scanf("%d", &B);

FSM Page 14
 Support langage C
if (A > B)
{
max = A ;
min = B;
}
else
{
max = B ; min = A;

}
printf("le max = %d et min = %d\n", max, min) ;
}

3.1.3 L’opérateur conditionnel ” ?”

L’opérateur conditionnel ” ?” est équivalent à l’instruction if else. Sa syntaxe est la
suivante :
condition ? expression1 : expression2
Cette expression est égale à expression1 si condition est satisfaite, et à expression2
sinon. Exemple : recherche du maximum de deux nombres entiers
if (a > b)
Max = a; équivalent à Max = (a > b ? a : b);
else
Max = b;

3.1.4 L’instruction switch

Sa forme la plus générale est celle-ci :
Algorithmique Langage C
selon (expression) faire switch (expression)
{
constante-1 : liste case constante-1 : liste d’instructions
1;
d’instructions 1 constante-2 : break ;
...
liste d’instructions 2 case constante-n : liste d’instructions
constante-n : liste d’instructions n ;
n break ;
default des
: liste d’instructions ;
L’expression est évaluée et comparée aux valeurs expressions constantes. Si sa valeur
autre : liste }
apparaı̂t dans une étiquette case, le contrôle du programme est transféré à cette
d’instructions finselon
étiquette, sinon il est transféré à l’étiquette default (si elle existe).
L’exécution se poursuit jusqu’à la fin du switch, à moins qu’une instruction de
rupture de séquence (break, return, continue, goto) ne soit rencontrée. Les
instructions de tous les cases suivant le case de branchement et du default s’il est
présent sont également exécutées. L’instruction switch est souvent utilisée avec
l’instruction break afin d’exécuter seulement les instructions spécifiques au case
sélectionné.
Exemple :
FSM Page 15
 Support langage C
Ecrire un programme permettant de calculer et d’afficher la somme ou la différence ou le
produit ou la division de deux entiers a et b saisis au clavier. Le choix de
l’opération est saisi par l’utilisateur :
1. + ou p : addition
2. - ou m : différence
3. * ou r : multiplication
4. / ou d : division
Ecrire ce programme en utilisant les
instructions if.

#include<stdio.h>
main()

{
char operation ;
int r, a, b ;
printf("Entrez un signe d’operation : ") ;
scanf("%c", &operation ) ;
printf("Entrez a : ") ;
scanf("%d", &a ) ;
printf("Entrez b : ") ;
scanf("%d", &b ) ;
if (operation == ’+’ || operation == ’p’)
r = a + b ;
else if (operation == ’*’ || operation == ’m’)
r = a * b ;
else if (operation == ’/’ || operation == ’f’)
r = a / b ;
else if (operation == ’-’ || operation == ’d’)
r = a - b ;
else
printf("Non valide ") ;
printf("%d %c %d = %d ", a, b, operation , r) ;
}

Réécrire ce programme en utilisant l’instruction switch.

#include<stdio.h>
main()
{
char operation ;
int r, a, b ;
printf("Entrez un signe d’operation : ") ;
scanf("%c", &operation ) ;
printf("Entrez a : ") ;
scanf("%d", &a ) ;
printf("Entrez b : ") ;

FSM Page 16
 Support langage C
scanf("%d", &b ) ;
switch (operation)
{
case ’+’ :
case ’p’ : r = a + b ; break;
case ’*’ :
case ’m’ : r = a * b ; break;
case ’/’ :
case ’f’ : r = a / b ; break;
case ’-’ :
case ’d’ : r = a - b ; break;
default : printf("Non valide!!!") ;
}
printf("%d %c %d = %d ", a, b, operation , r) ;
}

3.2 Les boucles

3.2.1 Boucle for
Algorithmique Langage C
pour v de vi à vf for( exp1 ; exp2 ; exp3
faire ){
Bloc Bloc d’instructions
d’instructions fin }
Avec : pour
– L’expression exp1 correspond à l’initialisation d’une variable de contrôle.
– L’expression exp2 est la condition de continuation de la boucle.
– L’expression exp3 est l’incrémentation de la variable de contrôle (elle est
effectuée après l’exécution de l’instruction).
Organigramme : Remarques :

– Les ne sont pas nécessaires lorsque le bloc ne comporte qu’une seule instruction.
– Les 3 instructions du for ne portent pas forcément sur la même
variable. Exemple 1 :
– for(i = 0 ; i<10 ; i++)

FSM Page 17
 Support langage C
{
............; /* bloc d’instructions */
............;
............;
}
– La boucle for( ; ; ) est une boucle infinie (répétition infinie du bloc d’instructions).
– Utilisation de variables différentes :
resultat = 0;
for(i = 0 ; resultat < 30 ; i++)
{

Exemple 2 :
............; /* bloc d’instructions */
............;
............;
resultat = resultat + 2 * i;

Ecrire un programme qui permet de calculer la somme des 50 premiers nombres entiers.
int i, somme = 0;

for (i = 0; i < 50; i++)

somme = somme +
i;
printf("Somme = %d\n", somme);

3.2.2 Boucle Do...While

Algorithmique Langage C
répéter do{
Bloc Bloc
d’instructions d’instructions
jusqu’à }while(condition)
Organigramme : (condition)

FSM Page 18
 Support langage C

Le bloc d’instruction sera exécuté tant que la condition est vérifiée (ou non nulle). Le
test se faisant après, le bloc est exécuté au moins une fois même si l’expression est
nulle à la première
évaluation.
Remarque
:
Les {} ne sont pas nécessaires lorsque le bloc ne comporte qu’une seule instruction.
Exemple :
Réécrire l’exemple 2 de la boucle for en utilisant la boucle do...while.
int i = 0, somme = 0;
do
{
somme = somme + i;
i = i+1;
}
while ( i < 50 );
printf("Somme = %d\n", somme);

3.2.3 Boucle While

Algorithmique Langage C
tantque (condition) while(condition){
faire Bloc
Bloc d’instructions
d’instructions fin }
Organigramme : tantque
Tant que la condition est vérifiée (ou non nulle), le bloc d’instruction est exécuté. Le
test ayant

FSM Page 19
 Support langage C

lieu avant l’exécution de l’instruction, celle-ci peut ne pas être exécutée si l’expression
est nulle
à la première
évaluation. Remarque
:
– Les {} ne sont pas nécessaires lorsque le bloc ne comporte qu’une seule
instruction.
– On peut rencontrer la construction suivante : while (condition) ; terminée par un ;
et sans
la présence du bloc d’instructions. Cette construction signifie : ”tant que la
condition est vraie attendre”.
expr1 ; expr1 ;
for(expr1 ;expr2 while(expr2){ do{
;expr3) ≡ instructions ; ≡ instructions ;
instructions ; expr3 ; expr3 ;
} }while(expr2) ;

Exemple : Réécrire l’exemple 2 de la boucle for en utilisant la boucle while.

int i = 0, somme = 0;
while ( i < 50 )
{
somme = somme + i;
i = i +1;
}
printf("Somme = %d\n", somme);

3.3 Les ruptures de séquences

 Support langage C

Dans le cas où une boucle commande l’exécution d’un bloc d’instructions, il
peut être
intéressant de vouloir sortir de cette boucle alors que la condition de passage est
encore va- lide. Ce type d’opération est appelé une rupture de séquence. Les ruptures
de séquence sont utilisées lorsque des conditions multiples peuvent conditionner
l’exécution d’un ensemble d’ins- tructions.
Les ruptures de séquence sont réalisées par quatre instructions qui correspondent à leur
niveau de travail :
– continue
– break
– goto

Break
On a vu le rôle de l’instruction break au sein l’instruction switch. L’instruction
break peut, plus généralement, être employée à l’intérieur de n’importe quelle boucle.
Elle permet d’inter- rompre le déroulement de la boucle, et passe à la première
instruction qui suit la boucle. En cas de boucles imbriquées, break fait sortir de la
boucle la plus interne.
Exemple : Soit le programme suivant :
main()
{
int i;
for (i = 0; i < 5 ; i++)
{
printf("i = %d\n", i);
if (i == 3)
break;
}
printf("valeur de i a la sortie de la boucle = %d\n", i);
}
Résultat d’exécution :
i= 0i= 1i = 2i = 3
valeur de i a la sortie de la boucle = 3.

3.3.2 Continue
L’instruction continue permet de passer directement au tour de boucle suivant, sans
exécuter les autres instructions de la boucle.
Exemple : Soit le programme
suivant :
main(
)
{
int i;
for (i = 0; i < 5; i++)
{

FSM Page 1
 if (i == 3)
continue;
printf("i = %d\n", i);
}
printf("valeur de i a la sortie de la boucle = %d\n", i);
}
Résultat d’exécution :
i= 0
i=1
i=2
i=4
valeur de i a la sortie de la boucle
= 5.
Goto
L’instruction goto permet d’effectuer un saut jusqu’à l’instruction étiquette
appelée label correspondant. Un label est une chaı̂ne de caractères suivie du double
point ” : ”.
Exemple :
main()
{
start :
... /* instructions */
...
goto stop; /* goto avant la définition de l’étiquette stop */
... /* instructions */
...
stop
:
... /* instructions */
goto start; /* goto après la définition de l’étiquette start */
...
}
Break et continue dans une boucle for :
for(expression 1 ; expression 2 ; expression 3)
{
instruction
1; break;
instruction
2; continue;
instruction
3;
}

FSM Page 2
Break et continue dans une boucle while :
while(condition)
{
instruction
1; break;
instruction
2; continue;
instruction 3;
}

Break et continue dans une boucle do while :

do
{
instruction 1;
break;
instruction 2;
continue;
instruction 3;

FSM Page 3
}
while(condition) ;

FSM Page 4
Chapitre 4

Les Tableaux

4.1 Les tableaux à une dimension

4.1.1 Déclaration
type nom[dim]
– type : définit le type d’éléments que contient le tableau. Un tableau en
langage C est composé uniquement d’éléments de même type.
– nom : est le nom du tableau.
– dim : est un nombre entier qui détermine le nombre des éléments du
tableau. Exemples :
int compteur[10]; //réservation de 10 cases pour des entiers, soit 40
octets float nombre[20]; //réservation de 20 cases pour des réels,
soit 80 octets

4.1.2 Accéder aux éléments

Pour accéder à un élément du tableau, il suffit de donner le nom du tableau, suivi de
l’indice de l’élément entre crochets : nom[indice]
Exemples :
compteur[2] = 5;
nombre[i] = 6.789;
printf("%d",compteur[i]
);
scanf("%f",&nombre[i]);
Remarques :
– L’indice du premier élément du tableau est 0.
– L’indice est toujours positif.
– L’indice du dernier élément du tableau est égal (dim- 1).

4.2 Les tableaux à plusieurs dimensions

4.2.1 Tableaux à deux dimensions
Déclaration
type nom[dim1][dim2]
Exemples :

FSM Page 5
 int compteur[4][5]; // 4 lignes, 5
colonnes float nombre[2][10]; // 2
lignes, 10 colonnes

Utilisation
Un élément du tableau est repéré par ses indices. En langage C les tableaux
commencent aux indices 0. Les indices maximum sont donc (dim1-1) et (dim2-1).

Appel
nom[indice1][indi
ce2] Exemples :
int tab[3][4];
tab[0][0] = 5;
printf("%d",
tab[i][j]);
scanf("%f",
&tab[i][j]);

Tableau[0][0] Tableau[0][1] Tableau[0][2] Tableau[0][3]

Tableau[1][0] Tableau[1][1] Tableau[1][2] Tableau[1][3]
Tableau[2][0] Tableau[2][1] Tableau[2][2] Tableau[2][3]

4.2.2 Tableaux à plusieurs dimensions :

On procède de la même façon en ajoutant les éléments de dimensionnement ou
les indices nécessaires.

4.3 Initialisation des tableaux

On peut initialiser les tableaux au moment de leur
déclaration : Exemples :
float nombre[4] = {2.67, 5.98 ,-8 ,0.09};
int x[2][3] = { {1, 5 ,7} , {8 ,4 ,3} }; /* 2 lignes et 3 colonnes
*/

4.4 Manipulation des tableaux

Pour la manipulation des tableaux, on utilise les boucles (for ou while ou do ...
while).
1. Saisit et affichage d’un tableau :
Ecrire un programme permettant de saisir un tableau de réel de taille 10 :
– Utilisation de la boucle for :
main()
{
float nombre[10];

FSM Page 6
 int i;
/* saisie du tableau*/
for( i=0; i<10; i++ ){
printf("nombre[%d] = ",
i); scanf("%f",
&nombre[i]);}
/* affichage du tableau*/
for( i=0; i<10; i++ )
printf("nombre[%d] = %f ",i,nombre[i]);
}
– Utilisation de la boucle while :

main()
{
float nombre[10];
int i;
i=0;
/* saisie du tableau*/
while(i<10){
printf("nombre[%d] = ",
i); scanf("%f",
&nombre[i]); i++;}
/* affichage du tableau*/
i=0;
while(i<10){
printf("nombre[%d] = %f ",i,nombre[i]);
i++;}
}
2. Calcul de la moyenne d’un tableau : Ecrire un programme permettant de saisir
un tableau de 10 entiers, de calculer et d’afficher leur moyenne.
main
()
{
int
tab[10];
int i,s;
float
moy;
/* saisie du
tableau*/
for(i=0;i<10;i++){
printf("tab[%d] =
",i); scanf("%d",
&tab[i]);}
/* calcule de la moyenne */
for(i=0; i<10; i++)
s = s+
tab[i];
FSM Page 7
 moy = s / 10;
/* affichage de la moyenne */
printf("Moyenne du tableau = %f", moy);
// ou bien printf("Moyenne du tableau = %f", float(s/10)
);
}
3. Recherche du maximum :
Ecrire un programme permettant de saisir les moyennes de 30 étudiants, de
calculer et d’afficher la meilleur moyenne.
main()
{
float moy[30];
int i;
float max;
/* saisie du tableau*/
for(i=0; i<10; i++)
{
printf("moy[%d] = ",i);
scanf("%f", &moy[i]);
}
max = moy[0] ;

/* recherche du maximum */
for(i=0; i<10; i++)
if (moy[i] >
max)
max =
moy[i];
/* affichage du maximum */
printf("Maximum du tableau = %f", max);
}
4. Saisit et affichage d’un tableau à 2 dimension :
Ecrire un programme permettant de saisir un tableau de réels de taille 5x10 :
main()
{
float nombre[5][10];
int i,j;
/* saisie du tableau*/
for( i=0; i<5; i++ )
for( j=0; j<10; j++ ){
printf("nombre[%d][%d] = ",
i); scanf("%f",
&nombre[i][j]);}
/* affichage du tableau*/
for( i=0; i<5; i++ ){
for( j=0; j<10; j++ )

FSM Page 8
 printf("nombre[%d][%d] = %f ", i, j, nombre[i][j] );
printf("\n")}
}

FSM Page 9
Chapitre 5

Les chaı̂nes de caractères

5.1 Déclaration
Une chaı̂ne est un tableau de caractères dont le dernier élément significatif est le
caractère
’\0’. Il faut donc différencier la longueur maximale de la chaı̂ne (c’est à dire la dimension
donnée lors de la définition) de sa longueur réelle (c’est à dire le nombre de caractères
jusqu’au ’\0’).
char
nom[dim]
Exemple :
char texte[dim] ;
Le compilateur réserve (dim-1) places en mémoire pour la chaı̂ne de caractères. En effet,
il ajoute toujours le caractère NULL (’\0’) à la fin de la chaı̂ne en mémoire

5.2 Initialisation
– char chaine[]=”HELLO” ;
H E L L O \0
– char chaine[6] = ”HELLO” ;
H E L L O \0
– char chaine[8] = ”Hello” ;
H E L L O \0 0 0
– char chaine[5] = ”HELLO” ;
⇒ Erreur pendant l’exécution

– char chaine[4] = ”HELLO” ;

⇒ Erreur pendant la compilation

5.3 Affichage
On peut utiliser la fonction printf avec le format %s :
char texte[10] = "BONJOUR";
printf("Voici le texte: %s\n", texte);
On peut aussi utiliser la fonction
puts :
puts(texte); // printf("%s\n",texte);

FSM Page 10
5.4 Saisie
On peut utiliser la fonction scanf avec le format le format %s. On n’écrit pas le
symbole &. On peut aussi utiliser la fonction gets.
char texte[10];
printf("entrer un texte: ");
scanf("%s", texte); /* gets(texte); */
Remarques :
– La fonction scanf ne permet pas la saisie d’une chaı̂ne comportant des espaces :
les ca- ractères saisis à partir de l’espace ne sont pas pris en compte mais rangés
dans le tampon d’entrée. Pour saisir une chaı̂ne comportant des espaces, il faut
utiliser la fonction gets.
– A l’issue de la saisie d’une chaı̂ne de caractères, le compilateur ajoute ’\0’ en
mémoire
après le dernier
caractère.
Exemples :
char lieu[25];
int jour, mois, annee;
printf("Entrez lieu et date de naissance :");
scanf("%s %d %d %d", lieu, &jour, &mois, &annee);

5.5 Tableau de chaı̂nes de caractères

Les tableaux de chaı̂nes de caractères sont des tableaux de tableaux de
caractères. Exemple :
char tab[5][10] = { "zero", "un", "deux", "trois", "quatre" };
Ce qui donne comme implémentation :
z e r o \0 ? ? ? ? ?
u n \0 ? ? ? ? ? ? ?
d e u x \0 ? ? ? ? ?
t r o i s \0 ? ? ? ?
q u a t r e \0 ? ? ?
On constate que le tableau contient de l’espace inutilisé relativement important
(près de la moitié). Pour minimiser la mémoire nécessaire au stockage des chaı̂nes, on
peut déclarer tab comme un tableau de pointeurs :
char *tab[5] = { "zero", "un", "deux", "trois", "quatre" };
Ce qui donne comme z e r o \0
implémentation :
u n \0
d e u x \0
t r o i s \0
q u a t r e \0

FSM Page 11
 5.6 Fonctions permettant la manipulation des
chaı̂nes
Les bibliothèques fournies avec les compilateurs contiennent de nombreuses
fonctions de traitement des chaı̂nes de caractères. En BORLAND C++, elles
appartiennent aux bibliothèques string.h ou stdlib.h. En voici quelques exemples de
fonctions de la bibliothèque string.h :
– strlen(< s >) Fournit la longueur de la chaı̂ne sans compter le ’\0’ final
– strcpy(< s >, < t >) Copie < t > vers < s >
– strcat(< s >, < t >) Ajoute < t > à la fin de < s >
– strcmp(< s >, < t >) Compare < s > et < t > lexicographiquement et fournit
un résulta t :
– négatif si < s > précède < t >
– zéro si < s > est égal à < t >
– positif si < s > suit < t >
– strncpy(< s >, < t >, < n >) Copie au plus ¡n¿ caractères de < t > vers < s
>
– strncat(< s >, < t >, < n >) Ajoute au plus ¡n¿ caractères de < t > à la fin
de < s >
– strchr(< s >, < c >) Trouve la première occurrence du caractère c dans la
chaı̂ne s, c’est
à dire la première fois où il apparaı̂t
– strrev (< s >) Inversion de l’ordre de la chaı̂ne s
– strupr (< s >) Conversion minuscule-majuscule de la chaı̂ne s

FSM Page 12