Ecole Nationale d'Ingnieurs de Tunis

Dpartement Technologie de l'Information et de la Communication

Langages de Programmation :
Langage C

Support de cours prpar par :

BEN HAMIDA EL ABRI Karima

SAMAALI Imen

Classes: 1re GC, GM et hydro

Anne universitaire 2008-2009

Chapitre 1 Structure dun programme C

1. Structure dun programme C
Un programme en C comporte :
Un entte (header) constitu de mta instructions ou directives destines au pr
processeur (par exemple : inclusion de librairies de fonctions prdfinies).
Un bloc principal appel main () : Qui reprsente la fonction principale (programme
principale en algorithmique).
Le corps des fonctions places avant ou aprs le main () dans un ordre quelconque, les
une aprs les autres. Partout, les variables et les fonctions font lobjet dune dclaration
prcisant leur type. Le schma gnral est donc :
En pascal

En C

Program Nom_prog ;
Uses crt, ;
Const PI=3.14 ;
Type nom_nouv_type = type;
Var i,j : integer;
Function nom_fct(paramtres) : type_retour ;
Var p : integer ;
Begin
P := 0;
{Commentaire : pascal ne fait pas de diff
entre maj P et min p }

nom_fct := ;
End ;

#include<stdio.h>
#define PI 3.14
typedef type nom_nouv_type ;
int i,j ;
type_retour function nom_fct (parameters)
{
int p = 0;
/* Commentaire : C fait la diffrence entre
maj P et min p */

return () ;
}
void function nom_prd (paramtres)

Procedure nom_prd (paramtres) ;

Var ;
Begin
;
end;

{
;
}

void main()
{
;
}

Begin
;
End.

Exemple : calcul de la surface dun cercle.

Langage C vers I

Langage C vers II

#include <stdio.h>
#define PI 3.14

#include <stdio.h>
#define PI 3.14

float f_surface(float rayon)

{float s;
s=rayon*rayon*PI;
return(s);
}

float f_surface(float);
void main()
{
float surface;
surface=f_surface(2.0);
printf("%f\n",surface);
}

void main()
{
float surface;
surface=f_surface(2.0);
printf("%f\n",surface);
}

float f_surface(float rayon)

{float s;
s=rayon*rayon*PI;
return(s);
}

2. Les composants lmentaires du C :

Un programme en langage C est constitu des six groupes de composants lmentaires
suivants :

les identificateurs
les mots-clefs
les commentaires
les constantes
les oprateurs
les signes de ponctuation.

On peut ajouter ces six groupes les commentaires, qui ne sont pas considrs par le pr
processeur.

2.1. Les identificateurs

Un identificateur est une suite de caractres parmi les lettres (minuscules ou majuscules,
mais non accentues), les chiffres, le tirait bas. (exemple : compte, Note_1, _indice)
Le premier caractre d'un identificateur ne peut pas tre un chiffre.
Les majuscules et minuscules sont diffrencies.
Le compilateur peut tronquer les identificateurs au-del d'une certaine longueur. Cette
limite dpend des implmentations, mais elle est toujours suprieure 31 caractres.

2.2. Les mots-clefs

Un certain nombre de mots, appels mots-clefs, sont rservs pour le langage lui-mme et ne
peuvent pas tre utiliss comme identificateurs. L'ANSI-C compte 32 mots clefs :
auto const double float int short struct unsigned
break continue else for long signed switch void
case default enum goto register sizeof typedef volatile
char do extern if return static union while

2.3. Les commentaires

Un commentaire dbute par /* et se termine par */. Par exemple,
/* Ceci est un commentaire */
On ne peut pas imbriquer des commentaires.
// nous permet dcrire un commentaire sur une mme ligne

2.4. Les constantes

Une constante est une valeur qui apparat littralement dans le code source d'un programme,
le type de la constante tant dtermin par la faon dont la constante est crite. Les constantes
vont tre utilises, par exemple, pour linitialisation de variables.
-

Les constantes entires

Une constante entire peut tre reprsente de 3 manires diffrentes suivant la base dans
laquelle elle est crite :
dcimale : par exemple, 0 et 2437 sont des constantes entires dcimales.
octale : la reprsentation octale d'un entier correspond sa dcomposition en base 8.
Les constantes octales doivent commencer par un zro. Par exemple, les reprsentations
octales des entiers 0 et 255 sont respectivement 00 et 0377.
hexadcimale : la reprsentation hexadcimale d'un entier correspond sa
dcomposition en base 16. Les lettres de a/A f/F sont utilises pour reprsenter les
nombres de 10 15. Les constantes hexadcimales doivent commencer par 0x ou 0X.
Par exemple, les reprsentations hexadcimales de 14 et 255 sont respectivement 0xe et
0xff.
-

Les constantes relles

Ils sont de lune des deux formes suivantes :

En notation dcimale : [+-]m.n ou m et n sont des entiers. Exemple : 2.5 , -123.47 , .
En notation scientifique : [+-]m.n [e/E][+-]p ou m,n et p sont des entiers. Exemple : 14.5 e-2 (-14.5 10-2)
-

Les constantes caractres

Elles sont sous une des formes suivantes :

x dsigne le caractre imprimable x ( Sauf lapostrophe et lantislash et les guillemets)
\nnn dsigne le caractre de code octal nnn (nnn est un nombre dans la base 8)
\\ dsigne le caractre \ (ou encore \134 en ASCII)
\ dsigne le caractre (ou encore \47 en ASCII)
\ " dsigne le caractre "
\n dsigne le caractre <newline> nouvelle ligne
-

Les constantes chanes de caractres

Une constante chane de caractres est une suite de caractres entours par des
guillemets. Par exemple,''Ceci est une chane de caractres'' (ATTENTION : en pascal
une chane est entoure par deux apostrophes ceci est une chane en pascal).
Elle peut contenir des caractres non imprimables, dsigns par les reprsentations vues
prcdemment. Par exemple, ''ligne 1 \n ligne 2''
A l'intrieur d'une chane de caractres, le caractre '' doit tre dsign par \''.
Enfin, le caractre \ suivi d'un passage la ligne est ignor. Cela permet de faire tenir de
longues chanes de caractres sur plusieurs lignes. Par exemple :

Sans espace

''ceci est une longue longue longue longue longue longue longue longue \
chane de caractres''
Remarque :
Le compilateur ajoute \0 la fin de la chane dans la mmoire.
Il faut savoir distinguer la constante caractre de la constante chane de caractre. Ainsi
x et "x" ne sont pas quivalents. Le premier reprsente la valeur numrique du caractre
x, le second est une chane ne comprenant quun caractre (la lettre x) en plus \0 final.

3. Les types de donnes

En C, il nexiste que quelques types fondamentaux de donnes :
Le type char : un seul byte reprsentant un caractre.
Le type int : un nombre entier dont la taille corresponds celles des entiers du SE.
Le type float : un nombre en virgule flottante en simple prcision.
Le type double : un nombre en virgule flottante en double prcision.
Des qualificatifs peuvent prciser le type int : short, long, unsigned, signed. Les qualificatifs
signed et unsigned peuvent prciser le type char. Le qualificatif long peut prciser le type
double. Quand une dclaration ne prcise pas le type de base, int est suppos le type par
dfaut.
Exemples :
short int x ;
unsigned long y ; /* int implicite */
Long double z ;
unsigned char ch ;

4. Dfinition de nouveaux types

Le langage C fournit une fonction appele typedef qui cre de nouveaux types de donnes.
Exemple :

typedef int entier ; /* fait du nouveau nom entier un synonyme de int. Ce type peut
tre utilis dans des dclaration, des casts exactement comme int. */
tyedef char* STRING ; /* fait de string un synonyme de char* */
typedef struct noeud {
char* mot ;
int quantite ;
}ARBRE ; /*cre un nouveau type appel ARBRE (une structure) */

On trouve aussi un constructeur de type par numration :

enum <identificateur> { liste de valeurs symboliques }
Exemple :

enum couleur { noir, bleu , vert , rouge, jaune } q1,q2 ;

Dfinit le type par numration nomm couleur et dclare deux variables q1 et q2 de ce type.
(exemple : q1=rouge ; q2=jaune ; ..).
4

5. Dclaration de variables
Les variables doivent tre dclares avant dtre utilises. A une variable correspond un
espace en mmoire et un mcanisme permettant dadresser cet emplacement. En C une
variable est caractris par :
Son nom (un identificateur)
Son type (type de base ou type dfinie par lutilisateur)
Une dclaration de variables a la forme :
type

liste de variables initialises ou non;

Exemples :
int var_globale1=0, var_globale2;
float var ;
int i,j,k ;
char backslash=\\ ;
int i=0 ;
float eps=1.0 e-5 ;

6. Dclaration de constantes
Les constantes doivent toutes tre dclares et initialises avant dtre utilises. Il existe 2
mthodes pour la dclaration des constantes.
Mthode 1 :
#define nom_cste valeur
/* Sans point virgule la fin */
Exemple : #define PI 3.14
Le compilateur ne rserve pas de place en mmoire. Les constantes dclares par #define
s'crivent traditionnellement en majuscules, mais ce n'est pas une obligation.
Mthode 2 :
const type nom_cste = valeur ;
Exemple : const float PI = 3.14 ;
Dans ce cas, le compilateur rserve de la place en mmoire (ici 4 octets), pour la variable PI,
mais dont on ne peut changer la valeur.
Remarques gnrales
1- Le type Boolen nexiste pas dans le langage C
2- Il ny a pas de notion de procdure en langage C
(On peut dire que une procdure
en langage C est une fonction sans rsultats void nom_procedure(paramtres) )
3- Le langage C ne permet pas de dclarer des fonctions lintrieur dautres fonctions

Cours Langages de Programmation

Chapitre 2 La syntaxe du langage C (les oprateurs)

1. L'affectation
En C, l'affectation est un oprateur et nest pas une instruction comme dans le pascal. Elle est
symbolise par le signe = . Sa syntaxe est la suivante :
variable = expression ;
Le terme de gauche de l'affectation peut tre une variable simple, un lment de tableau,
une structureetc. Cette expression a pour effet d'valuer expression et d'affecter la
valeur obtenue variable . De plus, cette expression possde une valeur, qui est celle
de expression . Ainsi, l'expression i = 5 vaut 5 .
L'affectation effectue une conversion de type implicite : la valeur de l'expression (terme
de droite) est convertie dans le type du terme de gauche. Par exemple, le programme
suivant :
main()
{
int i, j = 2;
float x = 2.3;
i = j + x;
x = x + i;
printf('' %f '',x);
}
Affiche sur lcran, pour x, la valeur 6.3 (et non 6.6), car dans l'instruction i = j + x;,
l'expression j +x a t convertie en entier (conversion implicite).

2. Les oprateurs arithmtiques

Les oprateurs arithmtiques classiques sont les suivants :
loprateur unaire - (changement de signe) ainsi que
les oprateurs binaires :

+ addition
soustraction
multiplication
/ division
% reste de la division (modulo) (pour les entiers)

Ces oprateurs agissent de la faon attendue sur les entiers comme sur les flottants. Leurs
seules spcificits sont les suivantes :
Contrairement d'autres langages, le C ne dispose que de la notation / pour dsigner la
fois la division entire et la division relle (loprateur div nexiste pas comme en
pascal).
o Si les deux oprandes sont de type entier, l'oprateur / produira une division
entire (quotient de la division).
o Par contre, il dlivrera une valeur flottante ds que lun des oprandes est un
flottant. Par exemple :
6

Cours Langages de Programmation

float x;
x = 3 / 2;
affecte x la valeur 1. Par contre
x = 3 / 2.0;
/* affecte x la valeur 1.5. */
L'oprateur % ne s'applique qu des oprandes de type entier.
Notons enfin quil n'y a pas en C doprateur effectuant llvation la puissance. De
faon gnrale, il faut utiliser la fonction pow(x,y) de la librairie math.h pour calculer
xy

3. Les oprateurs relationnels

Les oprateurs de comparaison sont les suivants :
Strictement suprieur
>= suprieur ou gal
< Strictement infrieur
<= infrieur ou gal
== gal
!= diffrent
Leur syntaxe est: expression1 op expression2
Les deux expressions sont values puis compares. La valeur rendue est de type int; elle vaut
0 si la condition est faux, et une valeur diffrente de 0 sinon.
FAUX = 0
VRAI 0

Attention !!!!

ne pas confondre l'oprateur de test dgalit == avec loprateur

daffection =. Ainsi, le programme
main()
{
int a = 0, b=1,c;
c= (a==b) ;
}
c contient la valeur 0 car a est diffrent b donc lvaluation de lexpression (a = = b) donne la
valeur boolenne Faux qui correspond la valeur 0 en C

4. Les oprateurs logiques boolens

Les oprateurs logique boolens sont les suivants :
&& et logique (AND) ;
|| ou logique (OR) ;

! ngation logique (NOT)

Comme pour les oprateurs de comparaison, la valeur retourne par ces oprateurs est un int
qui vaut 0 si la condition est faux.
Dans une expression de type : expression1 op1 expression2 op2 ...expressionN , lvaluation
se fait de gauche droite et s'arrte ds que le rsultat final est dtermin. Par exemple dans
int i=18,j=0;
if ((i >= 0) && (i <= 9) && !(j == 0))
La dernire expression !(j == 0) ne sera pas value si i n'est pas entre 0 et 9.
7

Cours Langages de Programmation

5. Les oprateurs d'affectation compose

Les oprateurs d'affectation compose sont
+= -= *= /= %= &= ^=

|=

Pour tout oprateur op, l'expression :

expression1 op= expression2 expression1 = expression1 op expression2
Exemple :
X*=Y ; equivalent X = X*Y ;

6. Les oprateurs d'incrmentation et de dcrmentation

Les oprateurs d'incrmentation ++ et de dcrmentation -- s'utilisent aussi bien en suffixe
aprs la variables (i++) ou (i--) qu'en prfixe avant la variable (++i) ou (--i). Dans les
deux cas la variable i sera incrmente ou dcrmente.
Dans la notation aprs la variable la valeur retourne sera l'ancienne valeur de i
Dans la notation avant la variable la valeur retourne sera la nouvelle.
Par exemple :
int a = 3, b, c;
b = ++a; /* aprs excution de cette instruction a et b valent 4
eq a=a+1 ;
b=a ; */
c = b++; /* aprs excution de cette instruction c vaut 4 et b vaut 5
eq c=b ;
b=b+1 ;*/

7. L'oprateur virgule
Une expression peut tre constitue d'une suite d'expressions spares par des virgules :
expression1, expression2, ..., expressionN
Cette expression est alors value de gauche droite. Sa valeur sera la valeur de l'expression
de droite. Par exemple, le programme
main()
{
int a, b;
b = ((a = 3), (a + 2));
// a=3 ; b=a+2 ;
printf(''\n b = %d \n'',b);
}
La valeur de b est 5
Autre exemple :
int i, j ;
i=(j=2, j++, j++); j=2; j=j+1; i=j; j=j+1; i = 3 et j = 4
La virgule sparant les arguments d'une fonction ou les dclarations de variables ne
reprsente pas l'oprateur virgule.

8. L'oprateur conditionnel ternaire

L'oprateur conditionnel ? est un oprateur ternaire. Sa syntaxe est la suivante :
condition ? expression1: expression2
8

Cours Langages de Programmation

Cette expression retourne val(expression1) si condition est vrai (diffrent de 0), et

val(expression2) sinon.
Par exemple,
abs_x = x >= 0 ? x : -x ; affecte dans abs_x la valeur absolue de x.
et

m = ((a > b) ? a : b); affecte m le maximum des deux variables a et b.

9. L'oprateur de conversion de type

L'oprateur de conversion de type, appel cast, permet de modifier explicitement le type d'un
objet. On crit (type)objet Par exemple :
main()
{
int i = 3, j = 2;
float r ;
r=(float)i/j;
}
r va contenir la valeur 1.5.

10. L'oprateur adresse

L'oprateur d'adresse & appliqu une variable retourne l'adresse mmoire de cette variable.
La syntaxe est &objet
Eemple :

Main()
{
int i=5 ;
printf("ladresse mmoire de i est : %x ",&i) ;
}

Affiche sur lcran ladresse mmoire de i sous forme hexadcimale : exemple FFF4

11. Rgles de priorit des oprateurs

Le tableau suivant classe les oprateurs par ordres de priorit dcroissants. Les oprateurs
placs sur une mme ligne ont mme priorit. Si dans une expression figurent plusieurs
oprateurs de mme priorit, l'ordre dvaluation est dfinie par la flche de la seconde
colonne du tableau. On prfrera toutefois mettre des parenthses en cas de doute.

Cours Langages de Programmation

Chapitre 3 Les fonctions dE/S standards

1. Introduction
Les fonctions dE/S standards sont les fonctions assurant lchange dinformation entre la
mmoire centrale et les priphriques standard, principalement le clavier et lcran.
Dans ce chapitre, nous allons examiner les fonctions permettant de lire les donnes partir du
clavier et dafficher les rsultats sur lcran.

2. Les fonctions dentres

2.1. La fonction scanf stdio.h
La fonction scanf, appartenant la bibliothque stdio.h, permet la saisie clavier de
n'importe quel type de variable.
Cette fonction lit partir de lentre standard (clavier) une liste de variables en mmoire selon
un format donn.
int scanf ( const char *format, liste d'adresses);
liste dadresse reprsente une liste dadresses de variables dclares auxquelles les donnes
lues seront attribues.
format reprsente le format de lecture des donnes. Cest une chane de caractres (donc
entour par des guillemets). Elle est compose de spcificateurs qui indique le type de
variables quon va lire. Chaque spcificateur correspond un type de variable et doit donc
apparatre dans le mme ordre que la variable dans la liste. Les principaux spcificateurs de
format sont rsum dans le tableau suivant.
Spcificateur de Signification
format
%d ou %x ou %o Pour une variable de type int (dcimale,
hexadcimale, octale)
%u
Pour une variable de type unsigned int
%h
Pour une variable de type short int
%f
Pour une variable de type float
%lf
Pour une variable de type double
%e
Pour une variable de type float mise sous
forme scientifique exp : 2.5E-2
%c
Pour une variable de type char
%s
Pour une variable de type texte
%li
Le type long

Exemple 1 :
int a = -1;
unsigned int b = 25;
char c = X;
scanf(%d%u%c,&a,&b,&c);

10

Cours Langages de Programmation

Remarque:
On peut placer la longueur de la variable entre le signe % et la lettre spcificateur. Par
exemple %3d indique quon va lire un entier de 3 chiffres et le reste des chiffres
sont ignors. scanf ("%3d",&i) ;
Si lon spare les spcificateurs de format par des espaces ou par des virgules alors les
valeurs lire seront spares par les mmes sparateurs.
Exemple 2:
char alpha;
scanf("%d",&alpha);
Si l'utilisateur saisie 97 tout va bien, alpha devient le caractre dont le code ASCII
vaut 97 qui est a.
Si l'utilisateur saisie a, sa saisie est ignore (PB !!!).
Exemple 3: (***)
Tout caractre ou nombre saisi au clavier et non pris en compte par la fonction scanf est
rang dans le tampon dentr qui est de type FIFO (First In First Out).
#include <stdio.h>
void main()
{
char c1,c2;
printf("ENTRER UN CARACTERE: ");
scanf("%c",&c1);
printf("VOICI SON CODE ASCII EN HEXADECIMAL: %x\n",c1);
printf("ENTRER UN AUTRE CARACTERE: ");
scanf("%c",&c2);
printf("VOICI SON CODE ASCII EN HEXADECIMAL: %x\n",c2);
}
Excution (trace) :
Si l'utilisateur saisit K pour c1, le programme donnera l'cran d'excution suivant:
ENTRER UN CARACTERE: K lutilisateur saisi K puis il a appuy sur RETURN donc on a
dans le tampon le caractre LF qui a le code ASCII en hxa a
: le tampon LF FIFO
VOICI SON CODE ASCII EN HEXADECIMAL: 4b
ENTRER UN AUTRE CARACTERE: VOICI SON CODE ASCII EN HEXADECIMAL: a

Le deuxime scanf reoit la valeur du tampon qui contient le

caractre retour la ligne LF qui est un caractre non
imprimable et de code ASCII a
La solution : En TURBOC la fonction flushall() permet de vider le tampon
d'entre. En l'invoquant aprs un appel scanf, on se dbarrasse des problmes
de flux d'entre.
2.2. La fonction gets stdio.h
Elle affecte une chane de caractre lue dans le flux en entre stdin dans s. Sa dclaration est
la suivante :
Char * gets (char * s) ;
Lorsquon lit une chane de caractres avec scanf, la lecture sarrte ds la rencontre dun
blanc. Avec la fonction gets, la lecture se termine la rception dun retour chariot \n.

11

Cours Langages de Programmation

Exemple :
#include <stdio.h>
void main()
{
char * CH;
gets(CH);
}
2.3. La fonction getchar() stdio.h
La fonction getchar permet la saisie d'un caractre (char). Elle appartient la bibliothque
stdio.h. Les 2 critures suivantes sont quivalentes:
char c;
printf("ENTRER UN CARACTERE: ");
scanf("%c",&c);

char c;
printf("ENTRER UN CARACTERE: ");
c = getchar();

Non formate, la fonction getchar est moins gourmande en place mmoire que scanf. Il vaut
mieux l'utiliser quand cela est possible; getchar utilise le flux d'entre exactement comme
scanf.
Autre fonction qui permet de saisir un seul caractre : int getch() ; de la bibliothque
conio.h . Cette fonction ne demande pas une validation par la touche entre pour rcuprer
le caractre saisi.
Exemple : c = getch() ;
Nous pouvons utiliser cette fonction sans rcupration du caractre saisi :
Exemple : getch () ;

3. Les fonctions de sorties

3.1. La fonction printf stdio.h
Elle permet la traduction de quantit alphanumrique en chane de caractres ainsi quune
prsentation formate de ditions.
int printf ( const char *format, liste dexpression);
format : format de reprsentation.
liste dexpression : variables et expressions dont les valeurs sont diter.
La premire partie est en fait une chane de caractres qui peut contenir
du texte
des squences dchappement qui permettent de contrler laffichage des donnes.
Exemple \n qui permet le passage la ligne suivante
des spcificateurs de format ou de conversion
Elle contient exactement un spcificateur de format pour chaque expression.
Exemple :
int i ;
printf(entrer une valeur :\n);
scanf(%d,&i);
i = i *2
printf(la nouvelle valeur de I est : %d,i) ;

12

Cours Langages de Programmation

Remarque:
1. printf ("%kd",n) ; Affiche au moins k caractres droite.
Exp1 : k=3 et n = 25 affiche _25 (tir bas remplace lespace)
Exp2 : k=2 et n = 355 affiche 355
2. printf ("%-kd",n) ; Affiche au moins k caractres gauche.
Exp1 : k=3 et n = 25 affiche 25_ (tir bas remplace lespace)
Exp2 : k=2 et n = 355 affiche 355
3. printf ("%f",x) ; Affiche le nombre rel en dcimal avec 6 chiffre aprs la virgule,
par dfaut.
Exp1 : x=1.5 1.500000
4. printf ("%kf",x) ; Affiche le nombre rel en dcimal avec 6 chiffre aprs la
virgule, par dfaut. Avec k reprsente la longueur minimale du
nombre.
Exp1 : k=9, x=1.5 _ _1.500000
5. printf ("%kf.J",x) ; Affiche le nombre rel en dcimal avec 6 chiffre aprs la
virgule, par dfaut. Avec k reprsente la longueur
minimale du nombre et J reprsente le nombre de chiffre
aprs la virgule.
Exp1 : k=9, J=3 ,x=1.5 _ _ _ _ _1.500
3.2. La fonction puts
Envoie une chane de caractres vers stdout et ajoute un saut de ligne (newline).
int puts (const char * s) ;
Exemple :
puts ( ceci est un exemple );
3.3. La fonction putchar
Envoie un caractre vers stdout (cran)
int putchar (int c) ;
Exemple :
char c ;
c= A
putchar (c);
putchar (B);

13

Cours Langages de Programmation

Chapitre 4 Les instructions de branchement

conditionnel
1. Instruction If else
if ( expression )
{
bloc d'instructions 1 ;
}
else
{
bloc d'instructions 2;
}
-

Si l'expression fournit une valeur diffrente de zro, alors le bloc d'instructions 1 est
excut
- Si lexpression fournit la valeur zro,
alors le bloc d'instructions2 est excut
- Attention !!! Les ( ), devant if , sont obligatoires.
Remarques :
o Les { } ne sont pas ncessaires lorsque les blocs ne comportent qu'une seule
instruction.
o On peut avoir des if imbriqus
Exemples :
if (a > b)
max = a;
else
max = b;
if (A-B)
printf("A est diffrent de B\n");
else
printf("A est gal B\n");
int a,b,c;
;
if (!a)
//quivalent if (a==0)
{
printf( cas o a = = 0 );
;
}
else // commentaire : cette partie traite le cas o a != 0
{
if (!b)
{
printf(cas o a != 0 et b = = 0);
;

21

Cours Langages de Programmation

}
else
{
printf(cas o a != 0 et b != 0 );
. ;
}

2. Instruction switch
Cest un moyen qui permet des choix multiples uniquement sur des entiers ou des caractres.

switch (choix)
{
case cst1 : liste d'instructions 1 ;
break;
case cst2 : liste d'instructions 1 ;
break;
.
default : liste instructions N ;
}

Remarques :
o Le bloc default nest pas obligatoire
o choix doit tre de type char ou int
o choix, cst1, cst2 et les autres valeurs sont de mme type
Linstruction break permet de sortir de linstruction switch. Elle est importante car si on ne la
met pas aprs chaque cas dexcution alors toutes les instructions aprs ce cas seront
excutes (bien sur sils ne sont pas suivis dune autre instruction break).
Exemple :
int mois ;
scanf(" %d" ,&mois) ;
switch ( mois )
{
case 1 : printf(" janvier" ) ; break ;
case 2 : printf(" fevrier" ) ; break ;

case 12 :printf(" dcembre" ); break ;

default : printf(erreur)
}

22

Cours Langages de Programmation

Chapitre 5 Les structures rptitives

1. Structure de While
while (expression)
{
bloc d'instructions ;
}
Tant que l'expression fournit une valeur diffrente de zro, le bloc d'instructions est
excut.
Les { } ne sont pas obligatoires, si le bloc dinstruction contient une seule instruction.
Les parenthses ( ) devant while sont obligatoires.

Exemple 1:
/* Afficher les nombres de 0 9 */
int I = 0;
while (I<10)
{
printf("%d \n", I);
I++;
}
/* Afficher les nombres de 0 9 */
int I = 0 ;
while (I<10)
printf(%d\n,I++);
/* Afficher les nombres de 1 10 */
int I = 0 ;
while (I<10)
printf(%d\n,++I);
Exemple2:
23

Cours Langages de Programmation

/* faire la somme des N premiers terme entier*/

int somme=0, i = 0;
while (i<N)
{
somme += i;
i++ ;
}
Exemple3:
/* Afficher des caractres */
unsigned char c=0;
while (c<255)
printf("%c \n", c++);

2. Structure do -While
do
{
bloc dinstructions;
} while ( expression );
- Le bloc d'instructions est excut au moins une fois et jusqu ce que l'expression fournit
une valeur gale zro (eq false).
- Les { } ne sont pas obligatoires, si le bloc dinstruction contient une seule instruction.

do - while est comparable la structure Repeat du langage Pascal la diffrence que la

condition finale est inverse logiquement.
La structure do - while est semblable la structure while, avec la diffrence suivante :

while value la condition avant d'excuter le bloc d'instructions.

do - while value la condition aprs avoir excut le bloc d'instructions. Ainsi le bloc
d'instructions est excut au moins une fois.

Une application typique de do - while est la saisie de donnes qui doivent remplir une certaine
condition.

Exemple1: Lecture dun nombre rel dans lintervalle [1 , 10]

24

Cours Langages de Programmation

float N;
do
{
printf("Introduisez un nombre entre 1 et 10 :");
scanf("%f", &N);
}
while (N<1 || N>10);
Exemple2 : division de deux entiers (diviseur doit tre diffrent de zro)
int n, div;
printf("Entrez le nombre diviser : ");
scanf("%d", &n);
do
{
printf("Entrez le diviseur ( != 0) : ");
scanf("%d", &div);
}
while (!div); //while (div==0)
printf("%d / %d = %f\n", n, div, (float)n/div);
Exemple3 : Lecture dun nombre rel positif
float N;
do
{
printf("Entrer un nombre (>= 0) : ");
scanf("%f", &N)
}
while (N < 0);
printf("La racine carre de %.2f est %.2f\n", N, sqrt(N));

3. Structure for
La structure pour en langage algorithmique est utilises pour faciliter la programmation de
boucles de comptage. La structure for en C est plus gnrale et beaucoup plus puissante.
for ( expr1 ; expr2 ; expr3 )
{
bloc d'instructions ;
}
Est quivalente :
expr1;
while (expr2 )
{
bloc d'instructions
expr3 ;
}

25

Cours Langages de Programmation

expr1 est value une fois avant le passage de la boucle. Elle est utilise pour initialiser les
donnes de la boucle.
expr2 est value avant chaque passage de la boucle. Elle est utilise pour dcider si la boucle
est rpte ou non.
expr3 est value la fin de chaque passage de la boucle. Elle est utilise pour rinitialiser les
donnes de la boucle.
En pratique, les parties expr1 et expr2 contiennent souvent plusieurs initialisations ou
rinitialisations, spares par des virgules.
Exemple1:
/* affichage des carrs des nombres entiers compris entre 0 et 20 */
int I;
for (I=0 ; I<=20 ; I++)
printf("Le carr de %d est %d \n", I, I*I);
/* Autre version : nest pas lisible */
int I;
for (I=0 ; I<=20 ; printf("Le carr de %d est %d \n", I, I*I), I++)
;
Exemple2 : Somme des nombres de 1 100
int n, tot;
for (tot=0, n=1 ; n<101 ; n++)
tot+=n;
printf("La somme des nombres de 1 100 est %d\n", tot);

26

Cours Langages de Programmation

Chapitre 6 Les pointeurs

1. Introduction
Toute variable manipule dans un programme est stocke quelque part en mmoire centrale.
Cette mmoire est constitue de mots qui sont identifis de manire unique par un numro quon
appelle adresse. Pour retrouver une variable, il suffit donc de connatre ladresse du mot o elle est
stocke ou (sil sagit dune variable qui recouvre plusieurs mots contigus) ladresse du premier de
ces mots. Pour des raisons videntes de lisibilit, on dsigne souvent les variables par des
identificateurs et non par leur adresses. Cest le compilateur qui fait alors le lien entre
lidentificateur dune variable et son adresse en mmoire. Toutefois, il est parfois trs pratique de
manipuler directement une variable par son adresse.

2. Adresse et valeur dune variable :

Une variable est caractrise par :
-

son adresse, cest dire ladresse mmoire partir de laquelle lobjet est stock.
sa valeur, cest dire ce qui est stock cette adresse.

Deux modes daccs :

Adressage direct: Accs au contenu d'une variable par le nom de la variable.

Exemple : (mot mmoire de taille 2 octets. type int cod sur 4 octets)
int A=10 ;

Adressage indirect: Accs au contenu d'une variable, en passant par un pointeur qui contient
l'adresse de la variable.
Exemple :
Soit A une variable contenant la valeur 10 et P un pointeur qui contient l'adresse de A. En
mmoire, A et P peuvent se prsenter comme suit:
Inta,P ;
P = &a ;

la valeur de a est gale la valeur de *P (Contenu de P)

3. Notion de pointeur :
Un pointeur est une variable dont la valeur est gale ladresse dun autre objet. On dclare un
pointeur par linstruction suivante :
Type * nom_du_pointeur ;
Type de lobjet point

Identificateur dont la valeur est

ladresse dun objet de type Type

Exemple :
// En Langage C
char * pc;
/*pc est un pointeur pointant sur un objet de type char*/
int *pi;
/*pi est un pointeur pointant sur un objet de type int*/
float *pf;
/*pf est un pointeur pointant sur un objet de type float*/

27

Cours Langages de Programmation

Loprateur unaire dindirection * permet daccder directement la valeur de lobjet point.

Ainsi si p est un pointeur vers un entier i, *p dsigne la valeur de i. Par exemple, le programme :
void main()
{
int i =3;
int * p ;
/* p est un pointeur sur une variable de type entier */
p=&i;
/* p contient ladresse de la variable i */
printf (\n contenu de la case mmoire point par p est : %d , *p) ;
*p=5;
/* p contient ladresse de la variable i */
printf (\n I = %d et *p = %d ,i, *p) ;
}

Imprime : contenu de la case mmoire point par p est : 3

i = 5 et *p = 5
Dans ce programme, les objets i et *p sont identiques. Ils ont mme adresse et valeur. Cela
signifie en particulier que toute modification de *p modifie i.

4. Allocation dynamique
Lorsque l'on dclare une variable char, int, float .... Un nombre de cases mmoire bien dfini est
rserv pour cette variable. Il n'en est pas de mme avec les pointeurs. Avant de manipuler un
pointeur, il faut linitialiser soit par une allocation dynamique soit par une affectation
dadresse p=&i. Sinon, par dfaut la valeur du pointeur est gale une constante symbolique
note NULL dfinie dans stdio.h En gnral, cette constante vaut 0.
On peut initialiser un pointeur p par une affectation sur p. Mais il faut dabord rserver p un
espace mmoire de taille adquate. Ladresse de cet espace mmoire sera la valeur de p. Cette
opration consistant rserver un espace mmoire pour stocker lobjet point sappelle allocation
dynamique. Elle se fait en C par la fonction malloc de la librairie standard stdlib.h Sa syntaxe
est la suivante :
char* malloc (nbr_octets)
Cette fonction retourne un pointeur de type char* pointant vers un objet de taille nbr_octets.
Pour initialiser des pointeurs vers des objets qui ne sont pas de type char*, il faut convertir le type
de la sortie de la fonction malloc laide dun cast.
Exemples : la fonction malloc
Exemple 1 :

char *pc;
int *pi,*pj,*pk;
float *pr;
pc = (char*)malloc(10);
/* on rserve 10 octets mmoire, soit la place pour 10 caractres */
pi = (int*)malloc(16);
/* on rserve 16 octets mmoire, soit la place pour 4 entiers */
pr = (float*)malloc(24);
/* on rserve 24 places en mmoire, soit la place pour 6 rels */
pj = (int*)malloc(sizeof(int)); /* on rserve la taille d'un entier en mmoire */
pk = (int*)malloc(3*sizeof(int));
/* on rserve la place en mmoire pour 3 entiers
on force le type int* */

28

Cours Langages de Programmation

Exemple 2 :
Le programme suivant :
#include <stdio.h>
#include <stdlib.h>
void main()
{
int *p ;
/* p est un pointeur vers un objet de type int */
printf( la valeur de p avant initialisation est : %d ,p) ;
p = (int*) malloc (sizeof(int)) ;
printf( \n la valeur de p aprs initialisation est :%x ,p) ;
*p = 2;
/* p contient la valeur 2 */
printf( \n la valeur de *p est :%d ,*p) ;
}

Imprime :
La valeur de p avant initialisation est : 0
La valeur de p aprs initialisation est : ff11
La valeur de *p est : 2
Analyse de lexemple :
Avant lallocation dynamique, *p na aucun sens et toute manipulation de *p gnrerait lerreur
suivante : segmentation fault.
Lallocation dynamique a pour rsultat dattribuer une valeur p et de rserver cette adresse un
espace mmoire compos de 4 octets pour stocker la valeur de *p.
Remarque1 :
Dans le programme :
#include <stdio.h>
main()
{ int i ;
int * p ;
p=&i ; }

i et *p sont identiques et on na pas besoin dallocation dynamique puisque lespace mmoire

ladresse &i est dj rserv pour un entier.
Remarque 2 :
La fonction calloc de la librairie stdlib.h a le mme rle que la fonction malloc mais elle initialise
en plus lobjet point *p 0. Sa syntaxe est la suivante :
calloc( nb_objets, taille_objet_octets)
Exemple :
Int n=10;
Int *p ;
p= (int*) calloc (n, sizeof(int)); /* tableau de n entiers*/

Est quivalent :
Int n=10;
Int *p ;
p= (int*) malloc (n * sizeof(int)); /* tableau de n entiers*/
For (i=0; i<n; i++) *(p+i)=0;

29

Cours Langages de Programmation

Enfin, lorsque lon na plus besoin de lespace mmoire alloue dynamiquement c'est--dire quand
on nutilise plus le pointeur p, il faut librer cette place en mmoire. Ceci se fait laide de
linstruction free qui a pour syntaxe :
free( nom_du_pointeur) ;
Libration de la mmoire : la fonction free
pi = (int*)malloc(16);
/* on rserve 16 octets en mmoire : la place pour 4 entiers */
pr = (float*)malloc(24);
/* on rserve 24 octets en mmoire : la place pour 6 rels */
.
free(pi);
/* on libre la place prcdemment rserve pour pi */
free(pr);
/* on libre la place prcdemment rserve pour pr */

Remarque :
*p++ quivalente *(p++)
++*p quivalente ++(*p)
*++p quivalente *(++p)

30

Cours Langages de Programmation

Chapitre 7 Les tableaux

1. Les tableaux une dimension

Dclaration et mmorisation

Dclaration

Dclaration de tableaux en C :
TypeSimple NomTableau [nombreCases] ;
Les noms des tableaux sont des identificateurs.
Exemples :
int notes [8] ; /* dclaration dun tableau nomm notes, de type int et de dimension 8 */
char tab [100] ; /* dclaration dun tableaux nomm tab, de type char et de dimension 100 */
float moy[40] ; /* dclaration dun tableau nomm moy, de type float et de dimention 100 */

Mmorisation

En C, le nom d'un tableau est le reprsentant de l'adresse du premier lment du tableau. Les
adresses des autres composantes sont calcules (automatiquement) relativement cette adresse.
Exemple:
char A[5] = {A, 66, 70, C, 240};

65

66

70

67

240

..

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

mmoire, alors le tableau occupera de N*M octets.
-

Initialisation et rservation automatique

Lors de la dclaration d'un tableau, on peut initialiser les composantes du tableau, en indiquant la
liste des valeurs respectives entre accolades.
Exemples :
int A[5] = {10, 20, 30, 40, 50};
float B[4] = {-1.05, 3.33, 87e-5, -12.3E4};
int C[10] = {1, 0, 0, 1, 1};
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 initialises par zro.
31

Cours Langages de Programmation

Si la dimension n'est pas indique explicitement lors de l'initialisation, alors l'ordinateur rserve
automatiquement le nombre d'octets ncessaires.
Exemples
int A[] = {10, 20, 30, 40, 50};
==> Rservation de 5*sizeof(int) octets
float B[] = {-1.05, 3.33, 87e-5, -12.3E4};
==> Rservation de 4*sizeof(float) octets

int C[] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};

==> Rservation de 10*sizeof(int) octets

Accs aux composantes

En dclarant un tableau par int A[5]; nous avons dfini un tableau A avec cinq composantes,
auxquelles on peut accder par:
A[0], A[1], ... , A[4]
Exemple :

Affichage et affectation

La structure for se prte particulirement bien au travail avec les tableaux. La plupart des
applications se laissent implmenter par simple modification des exemples-types de l'affichage et
de l'affectation.

Affichage du contenu d'un tableau : exemple

int A[5];
int I; /* Compteur */
for (I=0; I<5; I++)
printf("%d ", A[I]);

Affectation avec des valeurs provenant de l'extrieur : exemple

int A[5];
int I; /* Compteur */
for (I=0; I<5; I++)
scanf("%d", &A[I]);

32

Cours Langages de Programmation

2. Les tableaux deux dimension

Dclaration et mmorisation

dclaration

Dclaration de tableaux deux dimensions en C

TypeSimple NomTabl[NbreLigne][NbreCol];
Exemples :
double A[2][5] ; /* dclaration dun tableau deux dimension nomm A et de type double */
char B[4][2] ; /* dclaration dun tableau deux dimension nomm B et de type char */

Mmorisation

Comme pour les tableaux une dimension, le nom d'un tableau est le reprsentant de l'adresse du
premier lment du tableau (c--d l'adresse de la premire ligne du tableau). Les composantes d'un
tableau deux dimensions sont stockes ligne par ligne dans la mmoire.
Exemple: Mmorisation d'un tableau deux dimensions
short A[3][2] = {{1, 2 },
{10, 20 },
{100, 200}};
.

10

20

100

200

..

Lors de la dclaration d'un tableau, on peut initialiser les composantes du tableau, en indiquant la
liste des valeurs respectives entre accolades. A l'intrieur de la liste, les composantes de chaque
ligne du tableau sont encore une fois comprises entre accolades. Pour amliorer la lisibilit des
programmes, on peut indiquer les composantes dans plusieurs lignes.
Exemples
int A[3][10] ={{ 0,10,20,30,40,50,60,70,80,90},
{10,11,12,13,14,15,16,17,18,19},
{ 1,12,23,34,45,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 affectes ligne par ligne en passant de gauche droite. Nous
ne devons pas ncessairement indiquer toutes les valeurs: Les valeurs manquantes seront
initialises par zro. Il est cependant dfendu d'indiquer trop de valeurs pour un tableau.
Si le nombre de lignes L n'est pas indiqu explicitement lors de l'initialisation, l'ordinateur
rserve automatiquement le nombre d'octets ncessaires.

33

Cours Langages de Programmation

int A[][10] = {{ 0,10,20,30,40,50,60,70,80,90},

{10,11,12,13,14,15,16,17,18,19},
{ 1,12,23,34,45,56,67,78,89,90}};

Accs aux composantes

Laccs un lment dun tableau deux dimensions se fait selon le schma suivant :
NomTableau[Ligne][Colonne]
Les lments d'un tableau de dimensions L et C se prsentent de la faon suivante:
A[0][0]
A[1][0]
A[2][0]
. . .
A[L-1][0]

A[0][1]
A[1][1]
A[2][1]
. . .
A[L-1][1]

A[0][2]
A[1][2]
A[2][2]
. . .
A[L-1][2]

.
.
.
.
.

.
.
.
.
.

.
.
.
.
.

A[0][C-1]
A[1][C-1]
A[2][C-1]
. . .
A[L-1][C-1]

Affichage et affectation

Lors du travail avec les tableaux deux dimensions, nous utiliserons deux indices (p.ex: I et J), et
la structure for, souvent imbrique, pour parcourir les lignes et les colonnes des tableaux.

Affichage du contenu d'un tableau deux dimensions

int A[5][10];
int I,J;
/* Pour chaque ligne ... */
for (I=0; I<5; I++)
{
/* ... considrer chaque composante (colonne) */
for (J=0; J<10; J++)
printf("%7d", A[I][J]);
}

Affectation avec des valeurs provenant de l'extrieur

int A[5][10];
int I,J;
/* Pour chaque ligne ... */
for (I=0; I<5; I++)
/* ... considrer chaque composante (colonne) */
for (J=0; J<10; J++)
scanf("%d", &A[I][J]);

3. Pointeurs et tableaux :
Tout tableau en C est en fait un pointeur constant. Dans la dclaration :
int tab[10] ;

34

Cours Langages de Programmation

int *p;
p=tab; /* ou p= &tab[0]; adresse du premier lment */
. ;
/* les critures suivantes sont quivalentes :
tab[3] ou p[3] ou *(p+3) */

tab est un pointeur constant non modifiable dont la valeur est ladresse du premier lment du
tableau. Autrement dit tab a pour valeur &tab[0]. On peut donc utiliser un pointeur initialise tab
pour parcourir les lments du tableau.
Exemple :
int tab[5] = {2,1,0,8,4} ;
int *p ;
p= tab ;
/* ou p= &tab[0]; adresse du premier lment */
for (int i=0 ; i<5 ; i++)
{
printf ( %d \n,*p);
p++ ;
}

Qui est quivalent :

int tab[5] = {2,1,0,8,4} ;
int *p ;
p= tab ;
for (int i=0 ; i<5 ; i++)
printf ( %d\n,p[i] );

/* car *(p+i) = p[i] */

Qui est quivalent :

int tab[5] = {2,1,0,8,4} ;
int *p ;
for ( p=&tab[0] ; p<&tab[N]; p++)
printf ( %d \n,*p);

4. Tableau de pointeurs :
La dclaration dun tableau de pointeur se fait comme suit :
Type * NomTableau [N]
Cest la dclaration dun tableau NomTableau de N pointeurs sur des donnes du type Type.
Exemple :
char *JOUR[] = {"dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"};
/* affichage des 7 chane de caractres */
for (int I=0; I<7; I++) printf("%s\n", JOUR[I]);
/* affichage des premires lettres des jours de la semaine */
for (I=0; I<7; I++) printf("%c\n", *JOUR[I]);
/* affichage de la 3 eme lettre de chaque jourde la semaine */
for (I=0; i<7; I++) printf("%c\n",*(JOUR[I]+2));

35

Cours Langages de Programmation

Remarques :
Vous ne pouvez pas le droit de :
Comparer deux tableaux ; exp : int tab1[3], tab2[3] ; if (tab1>tab2) { } ATTENTION!
Affecter un tableau un autre : exp : tab1 = tab2 ; ATTENTION!
Dclarer un tableau de taille dynamique comme lexemple suivant : int n = 4 ; char T[n] ;

36

Cours Langages de Programmation

Chapitre 8 LES FONCTIONS

1. Dfinition de fonctions
Dfinition dune fonction en C :
TypeRsultatRetourn NomFonction (TypePar1 NomPar1, TypeParN NomParN, )
{
dclarations locales ;
instructions ;
}
Exemple 1 :
int somme_carre( int i , int j ) /* liste des noms et types des paramtres formels.
on ne peut pas crire : int somme_carre( int i , j ) */
{
int resultat;
/* declaration locale */
resultat = i*i + j*j;
return(resultat);
/* la valeur retourne, de type int */
}
Remarque :
Si nous choisissons un nom de fonction qui existe dj dans une bibliothque, notre fonction
cache la fonction prdfinie.
Une fonction peut fournir comme rsultat:

un type simple
une structure (dfinie par struct ),
une runion (dfinie par union ),
un pointeur,
void (la fonction correspond alors une 'procdure')

Une fonction ne peut pas fournir comme rsultat des tableaux, des chanes de caractres ou
des fonctions. Mais, il est cependant possible de renvoyer un pointeur sur le premier lment
d'un tableau ou d'une chane de caractres.
Si une fonction ne fournit pas de rsultat, il faut indiquer void (vide) comme type du rsultat.
Si une fonction n'a pas de paramtres, on peut dclarer la liste des paramtres comme (void)
ou simplement comme () .
Le type par dfaut est int; autrement dit: si le type d'une fonction n'est pas dclar
explicitement, elle est automatiquement du type int.
Il est interdit de dfinir des fonctions l'intrieur d'une autre fonction (comme en Pascal).
En principe, l'ordre des dfinitions dans le texte du programme ne joue pas de rle, mais
chaque fonction doit tre dclare ou dfinie avant d'tre appele.

37

Cours Langages de Programmation

2. Passage des paramtres par valeur

Exemple: fonction qui calcule le factoriel dun nombre N>0
Long int factoriel (int N)
{
long int fact = 1 ;
while (N>0)
{
fact=fact*N;
N--;
}
return (fact);
}
/* fonction qui calcule et affiche le factoriel des 10 premiers entiers */
void calcfact(void)
{
int L;
for (L=1; L<10; L++)
printf(%d,factoriel(L));
}
Au moment de l'appel, la valeur de L est copie dans N. La variable N peut donc tre
dcrmente l'intrieur de factoriel, sans influencer la valeur originale de L.

3. Passage de l'adresse d'une variable ( eq. passage par variable)

Comme nous l'avons constat ci-dessus, une fonction n'obtient que les valeurs de ses
paramtres. Pour changer la valeur d'une variable de la fonction appelante, il faut procder
comme suit:
-

la fonction appelante doit fournir l'adresse de la variable et

la fonction appele doit dclarer le paramtre comme pointeur.

Exemple : Fonction permettant d'changer la valeur de 2 variables :

Syntaxe qui conduit une erreur :

Syntaxe correcte :

#include <stdio.h>
void PERMUTER (int X,int Y)
{
int tampon;
tampon = X;
X = Y;
Y = tampon;
}

#include <stdio.h>
void PERMUTER (int *px,int *py)
{
int tampon;
tampon = *px;
*px = *py;
*py = tampon;
}

void main()
{
int A = 5 , B = 8;
PERMUTER(A,B);
printf( A=%d\n , A) ;
printf( B=%d\n , B) ;
}
PASSAGE DES PARAMETRES
PAR VALEUR

void main()
{
int A = 5 , B = 8 ;
PERMUTER(&A,&B);
printf( A=%d\n , A) ;
printf( B=%d\n , B) ;
}
PASSAGE DES PARAMETRES
PAR ADRESSE

38

Cours Langages de Programmation

Explication1: Lors de l'appel, les valeurs de A et B sont copies dans les paramtres X et Y.
PERMUTER change bien contenu des variables locales X et Y, mais les valeurs de A et B restent
les mmes.
Explication2: Lors de l'appel, les adresses de A et B sont copies dans les pointeurs px et py.
PERMUTER change ensuite le contenu des adresses indiques par les pointeurs A et B.

4. Passage de l'adresse d'un tableau une dimension

Cela consiste fournir l'adresse d'un lment du tableau. En gnral, on fournit l'adresse du
premier lment du tableau, qui est donne par le nom du tableau.
Dans la liste des paramtres d'une fonction, on peut dclarer un tableau par le nom suivi de
crochets ou simplement par un pointeur sur le type des lments du tableau.
Lors d'un appel, l'adresse d'un tableau peut tre donne par le nom du tableau, par un pointeur
ou par l'adresse d'un lment quelconque du tableau.
Exemple:
void LIRE_TAB1(int N, int *PTAB)
{ int i ;
printf("Entrez %d valeurs : \n", N);
for (i=0; i<N; i++)
scanf("%d", PTAB++);
}
/* ou une autre version */
void LIRE_TAB2(int N, int PTAB[])
{ int i ;
printf("Entrez %d valeurs : \n", N);
for (i=0; i<N; i++)
scanf("%d", PTAB[i]);
}
/* ou une autre version */
#define N 10
void LIRE_TAB3(int PTAB[N])
{ int i ;
printf("Entrez %d valeurs : \n", N);
for (i=0; i<N; i++)
scanf("%d", PTAB[i]);
}

Lors de lappel de ces diffrentes fonctions :

int tab[5], *p ;
LIRE_TAB1 (5, tab) ;
LIRE_TAB1 (5,&tab[0]) ;
p=tab ;
LIRE_TAB1 (5,p) ;
LIRE_TAB2 (5,tab) ;
LIRE_TAB3(tab) ;

Remarque :
Pour qu'une fonction puisse travailler correctement avec un tableau qui n'est pas du type char, il
faut aussi fournir la dimension du tableau ou le nombre d'lments traiter comme paramtre,
sinon la fonction risque de sortir du domaine du tableau.

39

Cours Langages de Programmation

5. Passage de l'adresse d'un tableau deux dimensions

Une solution praticable consiste faire en sorte que la fonction reoive un pointeur (de type
float*) sur le dbut de la matrice et de parcourir tous les lments comme s'il s'agissait d'un tableau
une dimension N*M.
Exemple:
float SOMME(float *A, int N, int M)
{
int I;
float S;
for (I=0; I<N*M; I++)
S += A[I];
return S;
}
Voici un programme faisant appel notre fonction SOMME:

#include <stdio.h>
main()
{
/* Prototype de la fonction SOMME */
float SOMME(float *A, int N, int M);
/* SOMME(&T[0][0], 3, 4) ); */
/* Dclaration de la matrice */
float T[3][4] = {{1, 2, 3, 4},
{5, 6, 7, 8},
{9,10,11,12}};
/* Appel de la fonction SOMME */
printf("Somme des lments : %f \n",
SOMME((float*)T, 3, 4) );
return 0;
}

Remarque : protection des variables de type tableau lors du passage comme paramtre dans une
fonction ; exemple : int lire_tab (const char *t) ;

40

Cours Langages de Programmation

Chapitre 9 Les types de variables complexes

(Structures, union et numration)
1. Notion de structure
C'est un mcanisme permettant de grouper un certain nombre de variables de types diffrents au
sein d'une mme entit en utilisant le concept denregistrement. Un enregistrement est un ensemble
d'lments de types diffrents reprs par un nom. Les lments d'un enregistrement sont appels
des champs. Le langage C possde le concept d'enregistrement appel structure.

2. Dclaration de structure :
Mthode 1 : dclaration en prcisant un nom pour la structure
struct
{
char nom[20];
char prenom[20];
int
n_cin;
} personne;
Dclare l'identificateur personne comme tant le nom d'un type de structure, compose de trois
membres. On peut ensuite utiliser ce type structure pour dclarer des variables, de la manire
suivante :
struct personne p1,p2; /* qui dclare deux variables de type
struct personne de noms p1 et p2 */
Mthode 2 : dclaration en prcisant un nom pour la structure et en dclarant des variables (combiner)
struct
{

char nom[20];
char prenom[20];
int n_cin;
} personne p1,p2;

Dclare les deux variables p1 et p2 et donne le nom personne la structure. L aussi, on pourra
utiliser ultrieurement le nom struct personne pour dclarer d'autres variables :
Mthode 4 : dclaration en utilisant typedef
typedef struct
/* On dfinit un type struct */
{
char nom[10];
char prenom[10];
int age;
float moyenne;
} fiche;

41

Cours Langages de Programmation

Utilisation : On dclare des variables par fiche et non par struct fiche :

fiche f1,f2;

3. Accs aux membres dune structure :

Pour dsigner un membre d'une structure, il faut utiliser l'oprateur de slection de membre qui
se note '.' (Point).
Exemple 1 :
struct
{
char nom[20];
char prenom[20];
int age;
} personne;
struct personne p1,p2;
p1.age=15 ; /* accs au troisime champs + affectation */
scanf ("%s",p1.nom) ;
/* lecture du premier champs */
printf("%s",p1.prenom) ; /* affichage du deuxime champs */
p2.nom[0] = 'X';

4. Initialisation dune structure :

Exemple1 :
struct personne pr1 = {"Sami", "Ben sassi", 55};
Exemple2 :
struct personne pr2;
/* dclaration de pr2 de type struct personne */
strcpy ( pr2.nom, "Sami" ) ; /* affectation de "jean" au deuxime champs */
strcpy ( pr2.prenom, "Ben sassi" ) ;
pr2.age = 164 ;
Remarque :
On ne peut pas faire linitialisation dune structure lors de sa dclaration.

5. Affectation de structures :
On peut affecter une structure une variable structure de mme type.
struct personne pr1,pr2;
pr1 = pr2 ;

6. Comparaison de structures :
Aucune comparaison n'est possible sur les structures, mme pas les oprateurs == et !=.

42

Cours Langages de Programmation

7. Tableau de structures :
Une dclaration de tableau de structures se fait selon le mme modle que la dclaration d'un tableau dont
les lments sont de type simple. Supposons que l'on ait dj dclar la struct personne.

struct personne t[100];

/* dec dun tableau de 100 structures de type struct personne */

Pour rfrencer le nom de la personne qui a l'index i dans t on crira : t[i].nom.

8. Composition de structures :
Une structure permet de dfinir un type. Ce type peut tre utilis dans la dclaration dune autre
structure comme type dun de ses champs.
Exemple :

struct
{
unsigned int jour;
unsigned int mois;
unsigned int annee ;
} date;
struct
{
char nom[20];
char prenom[20];
struct date d_naissance;
} personne;

9. Pointeur et structures :
Supposons que l'on ait dfini la struct personne l'aide de la dclaration :
struct
{

char nom[20] ;
unsigned int age ;
} personne;

On dclarera une variable de type pointeur vers une telle structure de la manire suivante :
struct personne *p ;

On pourra alors affecter p des adresses de struct personne. Exemple :

struct personne pers; /* pers est une variable de type struct personne */
struct personne *p; /* p est un pointeur vers une struct personne */
p = &pers;
(*p).age=20 ; /* parenthses obligatoires OU */
p -> age=22 ; /* -> oprateur daccs */
;

10. Les numrations :

Les numrations permettent de dfinir un type par la liste des valeurs quil peut prendre. Un
objet de type numration est dfini par le mot clef enum et un identificateur de modle suivis de
la liste des valeurs que peut prendre cet objet.

43

Cours Langages de Programmation

Exemple1 :
enum jour {LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI, DIMANCHE};
enum jour j1, j2;
j1 = LUNDI;
j2 = MARDI;
enum jour {LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI, DIMANCHE} d1, d2;
enum {FAUX, VRAI} b1,b2; /* mauvaise programmation */

11. Les unions :

Une union dsigne un ensemble de variables de types diffrents susceptibles doccuper
alternativement une mme zone mmoire. Une union permet donc de dfinir un objet comme
pouvant tre dun type au choix parmi un ensemble fini de types. Si les membres dune union sont
de longueurs diffrentes la place rserve en mmoire pour la reprsenter correspond la taille du
membre le plus grand.
union jour
{
int numero;
char lettre;
};
union jour hier, demain ; /* dclaration de deux variables de type union jour */
hier.numero = 5 ;
hier.lettre=D ;
/* crase la valeur prcdente */
Remarque :
La diffrence smantique entre les struct et les unions est la suivante : alors que pour une
variable de type structure tous les membres peuvent avoir en mme temps une valeur, une variable
de type union ne peut avoir un instant donn qu'un seul membre ayant une valeur.
-

Utilisation des unions

enum type {ENTIER, FLOTTANT};

struct arith
{
enum type typ_val;
/* indique ce qui est dans u */
union
{
int i;
float f;
} u;
};
La struct arith a deux membres typ_val de type enum type, et u de type union d'int et de float. On
dclarera des variables par :
struct arith a1,a2;
Puis on pourra les utiliser de la manire suivante :
a1.typ_val = ENTIER;
44

Cours Langages de Programmation

a1.u.i = 10;
a2.typ_val = FLOTTANT;
a2.u.f = 3.14159;
Si on passe en paramtre une procdure un pointeur vers une struct arith, la procdure testera
la valeur du membre typ_val pour savoir si l'union reue possde un entier ou un flottant.
Exercice corrig :
Crer une structure point{int num;float x;float y;}
Saisir 4 points, les ranger dans un tableau puis les afficher.

Corrig :
#include <stdio.h>
#include <conio.h>
typedef struct {int num;float x;float y;} point;
void main()
{
point p[4];
/* tableau de points */
int i;
float xx,yy;
/* saisie */
printf("SAISIE DES POINTS\n\n");
for(i=0;i<4;i++)
{
printf("\nRELEVE N %1d\n",i);
p[i].num = i;
printf("X= ");scanf("%f",&xx);
printf("Y= ");scanf("%f",&yy);
p[i].x = xx;p[i].y = yy;
}
/* relecture */
printf("\n\nRELECTURE\n\n");
for(i=0;i<4;i++)
{
printf("\nRELEVE N%1d",p[i].num);
printf("\nX= %f",p[i].x);
printf("\nY= %f\n",p[i].y);
}
printf("\n\nPOUR SORTIR FRAPPER UNE TOUCHE ");
getch();
}

45

Cours Langages de Programmation

Chapitre 10 Les chanes de caractres

Il n'existe pas de type spcial chane ou string en C. Une chane de caractres est traite comme un
tableau une dimension de caractres.

1. Dclaration :
La dclaration dune chane de caractre se fait par lune des mthodes suivantes :
char NomChaine [Longueur];
OU
char * NomChaine ;
Exemple :
char NOM [20];
/* dclaration sans initialisation */
char PRENOM [] = "stream";
/* dclaration avec initialisation : tab de 7 caract "stream\0" */
char adresse1 [] = { c, h,a, r ,g,u,i,a,\0} ; /* dclaration avec initialisation */
char adresse2 [20] = { c, h,a, r ,g,u,i,a,\0} ; /* dclaration avec initialisation */
char * CH1 ;
/* dclaration sans initialisation */
char * CH2= " voila" ;
/* dclaration avec initialisation */
CH1 = " affectation permise" /* affectation permise*/
NOM = " chaine" /* !!!! attention affectation non permise*/

2. Mmorisation :
Le nom d'une chane est le reprsentant de l'adresse du premier caractre de la chane. Pour
mmoriser une variable qui doit tre capable de contenir un texte de N caractres, nous avons
besoin de N+1 octets en mmoire:
Exemple :
char TXT [10] = "BONJOUR !";

3. Accs aux lments :

Exemple :

char A [6] = "hello";

ou
char *A ="hello";

Remarque : A[i] est quivalent *(A+i)

4. Utilisation des chanes de caractres :

Les bibliothques de fonctions de C contiennent une srie de fonctions spciales pour le
traitement de chanes de caractres.
46

Cours Langages de Programmation

Les fonctions d'E/S:
Exemples : les fonctions de stdio.h
/*----- Affichage -----*/
char TXT [6] = "hello";
char CH[5] ;
printf ("%s",TXT) ;
/* affiche hello sans retour la ligne*/
printf ("%s",&TXT[3]) ;
/* affiche lo sans retour la ligne*/
printf ("%.3s", TXT) ; /* affiche hel */
puts ( TXT) ;
/* affiche hello avec un retour la ligne */
puts (" bonjour") ;
/* affiche bonjour avec un retour la ligne */
/* ---- Lecture ------*/
scanf ("%s", CH) ;
/* Lecture d'une chane sans espaces */
gets(CH) ; /* Lecture d'une chane avec des espaces */

LES FONCTIONS DE CONCATENATION DE CHAINES

La concatnation est la juxtaposition de chanes afin den former une seule. Elle est ralise en C
laide de lune des deux fonctions strcat et strncat (string. h)
(A). La fonction strcat
Lappel de strcat se prsente ainsi :
char *strcat (char *destination, char *source)
Cette fonction recopie la seconde chane source la suite de la premire destination, aprs en
avoir effac le caractre de fin.
Remarques :
1. Aucun contrle de longueur nest ralis par cette fonction ; il est ncessaire que l'emplacement
rserv pour la premire chane soit suffisant pour y recevoir la partie lui concatner.
2. strcat fournit un rsultat :
ladresse de la chane correspondant la concatnation des deux chanes fournies en
argument, lorsque lopration sest bien droule. Qui est ladresse de destination.
Le pointeur NULL lorsque lopration est mal droule.
Examinons cet exemple :
#include <string.h>
main ()
{
char ch1[50]=bonjour ;
char *ch2=monsieur;
printf (avant :
%s\n , ch1);
strcat (ch1, ch2);
printf (aprs :
%s\n,ch 1);
}

Imprime sur lcran :

avant : bonjour
aprs : bonjourmonsieur

Il faut noter la diffrence entre les deux dclarations (avec initialisation) de chacune des deux
chanes ch1 et ch2. La premire permet de rserver un emplacement plus grand que la constante
chane que y trouve place initialement.
(B). La fonction strncat
Cette fonction, dont lappel se prsente ainsi :
char* strncat (char *destination , char *source , int n)

47

Cours Langages de Programmation

Permet de copier n caractres de la chane source la fin de la chane destination (mme le
caractre \0).
Examinons cet exemple :

#include <string. h>

main()
{
char ch1[50] = "bonjour" ;
char *ch2 = " monsieur";
printf(avant %s\n,ch1);
strncat (ch1,ch2,2);;
printf(apres:%s\n,ch1);
}

Imprime su l'cran :
avant :bonjour
aprs :bonjour m
-

FONCTION LONGUEUR DE CHAINES

Cette dernire sobtiendra par la fonction strlen. Par exemple :

int strlen(char *ch)
Fournit une valeur de type int correspondant la longueur de la chane ch. Le caractre nul de fin
(\0), ntant pas comptabilis.
Exemple : lg = strlen ("ALI\0"); lg = 3
-

LES FONCTIONS DE COMPARAISON DE CHAINES

Il est possible de comparer deux chanes en utilisant lordre des caractres dfini par le code
ASCII.
Code ASCII de 'a' = 97 et celui de 'A' = 65 'a' > 'A'
(A).

La fonction strcmp : (string. h)

int strcmp (char *ch1, char *ch2)

Compare deux chanes et elle fournit une valeur entire dfinie comme tant :
positive
si ch1 > ch2
nulle cd 0 si ch1 = ch2
ngative
si ch 1 < ch2
Par exemple :
strcmp(bonjour , monsieur) est ngatif et
strcmp(Tunis2 , Tunis10) est positif.
(B).

La fonction strncmp : (string.h)

int strncmp (char *ch, char *ch2, int lgmax)

Travaille comme strcmp mais elle limite la comparaison au nombre maximum de caractres
indiqu par lenlier lgmax.
Par exemple :
strncmp(bonjour , bon, 4) est positif tandis que
strcmp(bonjour , bon , 2)
vaut zro.

48

Cours Langages de Programmation

(C).

les deux fonctions stricmp et strnicmp (string.h)

int stricmp (char *ch1, char *ch2)
int strnicmp (char *ch1, char *ch2, int lgmax)

Travaillent respectivement comme strcmp et strncmp, mais sans tenir compte de la diffrence entre
majuscules et minuscules (pour les seuls caractres alphabtiques).
(A).

LES FONCTIONS DE COPIE DE CHAINES

La fonction strcpy: (string.h)

char *strcpy (char *destin, char *source)

Recopie la chane situe ladresse source dans lemplacement dadresse destin.

(B).

b) La fonction strncpy: (string.h)

char* strncpy (char *destin, char *source, int n)

Procde de manire analogue strcpy, en faisant la recopie au nombre de caractres prciss par n.
Il faut noter que si la longueur de la chane source est infrieure cette longueur maximale (n) son
caractre de fin sera effectivement recopi. Mais dans le cas contraire, il ne le sera pas. Lexemple
suivant illustre les deux situations :
L'exemple suivant :
#include <string. h>
main()
{

char ch1 [20] = 0123456789;

char ch2[20];
printf(donnez un mot:);
gets(ch2) ;
strncpy(ch1, ch2, 6);
printf(%s, ch1);
}

Imprime pour exec1:

donnez un mot: bon
bon
-

Imprime pour exec2:

donnez un mot: bonjour
bonjou6789

LES FONCTIONS DE RECHERCHE DANS UNE CHAINE

On trouve des fonctions de recherche de loccurrence dans une chane, dun caractre ou dune
autre chane (nomme alors sous-chane).
Ces fonctions fournissent comme rsultat :
ladresse de linformation cherche on cas de succs
le pointeur null dans le cas contraire.
char *strchr (char *chane, char caractre)

(string.h)

Recherche, dans chane la premire position o apparat le caractre mentionn

char *strrchr (char *chane, char caractre) (string.h)

49

Cours Langages de Programmation

Ralise le mme traitement que strchr, mais en explorant la chane mentionn partir de la fin.
Elle fournit donc la dernire occurrence du caractre mentionn.
char *strstr (char *chane, char *sous-chane)

(string.h)

Recherche dans chane la premire occurrence complte de la sous-chane mentionne (respectant

MIN et MAJ).
char *strpbrk (char *chane 1, char *chaine2) (string. h)
Recherche, dans chane1 la premire occurrence dun caractre quelconque de chaine2.
Voici un programme illustrant le fonctionnement de ces quatre fonctions :
#nc/ude <string.h>
#define c e
#define sch "re"
#define voy "aeiou"
main()
{
char mot[40];
char *adr ;
printf(donnez un mots:);
gets (mot);
if (adr=strchr(mot,c))
printf(Premire occurrence de%c en %s\n et pos = %d \n,c,adr, adr-mot);
if (adr=strrchr(mot,c))
printf(Dernire occurrence de %c en %s\n et pos = %d \n,c, adr, adr-mot) ;
if (adr = strstr(mot,sch))
printf (Premire occurrence de %s en %s\n et pos = %d \n,sch,adr, adr-mot) ;
if (adr =strpbrk(mot,voy))
printf (Premire occurrence de lune des lettres de %s en %s\n et pos = %d \n,voy,adr,adr-mot) ;
}

Imprime sur l'cran :

Donnez un mot : correspondances
Premire occurrence de e en espondances et pos = 4
Dernire occurrence de e en es et pos = 13
Premire occurrence de re en repondances et pos = 3
Premire occurrence de lune des lettres de aeiou en orrespondances et pos = 1
(A).

LES FONCTIONS DE CONVERSION

Conversion dune chane en une valeur numrique

Il existe trois fonctions permettant de convertir une chane de caractres en une valeur numrique
de type int, long ou double. Ces fonctions ignorent les ventuels espaces de dbut de chane et
utilisent les caractres suivant pour fabriquer une valeur numrique. Le premier caractre invalide
arrte lexploration. Par contre, si aucun caractre nest exploitable, ces fonctions fournissent un
rsultat nul (0).
atoi (chaine) (stdlib.h)

50

Cours Langages de Programmation

Fournit un rsultat de type int;
atol(chaine)

(stdlib.h)

Fournit un rsultat de type long;

atof(chaine)

(stdlib.h)

Fournit un rsultat de type double;

Voici un programme illustrant les possibilits de atoi et atof:
#include <stdlib. h>
main()
{
char ch[40] ;
int n;
do
{
printf(donnez une chane :) ;
gets(ch);
printf(----->int
:%d\n, atoi(ch));
printf(----->double :%e\n ,atof(ch));
} while(n);
}

Imprime sur l'cran :

(exp1) donnez une chane : 123
----->int
:123
----->double :1.230000e+02
(exp2) donnez une chaine :-123.45
----->int
:-123
----->double :-1.234500e+02
(exp3) donnez une chane : 123.45e6
----->int
:123
----->double :1.234500e+08
(exp4) donnez une chane :0
----->int
:0
----->double
(B).

:0.000000e+00

Conversion dune valeur numrique en une chane

Nous nous limiterons ici au fonctions de conversion dun entier en une chane (il existe des
fonction permettant de convenir un nombre flottant on une chane). Celles-ci permettent
dexprimer un nombre non seulement sous forme dune suite de chiffres en base 10, mais
galement dans nimporte quelle base comprise entre 2 et 36. Elles sont particulirement bien
adaptes pour afficher par exemple un nombre en binaire.
Ces trois fonctions fournissent en rsultat un pointeur sur la chane obtenue
char* itoa ( int entier,char *chaine, int base )
(stdlib.h)
Travaille avec un entier de type int.
char* itol ( long entier, char *chaine, int base )
Travaille avec un entier de type long.

51

(stdlib.h)

Cours Langages de Programmation

char* ultoa (unsigned long entier,cher *chaine, int base )

(stdlib.h)

Travaille avec un entier de type unsigned long.

Voici un exemple dutilisation de la fonction itoa :
#include <stdlib. h>
main()
{
char ch[40];
int n,b;
do
{
printf(Donner un nombre et une base :) ;
scanf(%d %d, &n, &b);
printf( ==>%s\n, itoa(n, ch, b));
}while(n) ;
}

Donner un nombre et une base : -123 10

==> -123
Donner un nombre et une base : 15 16
==> f
Donner un nombre et une base : 200 2
==> 11001000
Donner un nombre et une base : 0
(C).

les fonctions de ( ctype.h)

Les fonctions de <ctype> servent classifier et convertir des caractres. Dans la suite, c
reprsente une valeur du type int qui peut tre reprsente comme caractre.
isupper(c) ; /* retourne une valeur diffrente de zro si c est une majuscule */
islower(c) ; /* retourne une valeur diffrente de zro si c est une minuscule */
isdigit (c) ; /* retourne une valeur diffrente de zro si c est un chiffre dcimal */
isalpha(c) ; /* retourne une valeur diffrente de zro si isupper(c) ou islower(c) */
isalnum(c) ; /* retourne une valeur diffrente de zro si isalpha(c) ou isdigit (c) */
isxdigit(c) ; /* retourne une valeur diffrente de zro si c est un chiffre hexadcimal */
isspace(c) ; /* retourne une valeur diffrente de zro si c est un signe despacement */

Les fonctions de conversion suivantes fournissent une valeur du type int qui peut tre
reprsente comme caractre; la valeur originale de c reste inchange:
char tolower(c) ; /* retourne c converti en minuscule si c est une majuscule */
char toupper(c) ; /* retourne c converti en majuscule si c est une minuscule */

5. Tableaux de chane de caractres :

Souvent, il est ncessaire de mmoriser une suite de mots ou de phrases dans des variables. Il
est alors pratique de crer un tableau de chanes de caractres, ce qui allgera les dclarations des
variables et simplifiera l'accs aux diffrents mots (ou phrases).
Declaration : elle se fait par lune des deux mthodes
char JOUR [7] [9];
char * mois [12] ;

52

Cours Langages de Programmation

Initialisation : lors de la dclaration.
char JOUR [7] [9]= {"lundi", "mardi", "mercredi","jeudi", "vendredi", "samedi","dimanche"};
char * MOIS [12] = {"jan", "fev", "mars","avr", "may", "juin","juil","aout", "sep", "oct","nov", "dec"};

Accs aux diffrentes composantes :

Printf ("%s", JOUR [2]); /* affiche mercredi */
Printf ("%s", MOIS [0]); /* affiche jan */

Accs aux caractres : (similaire au cas des tableaux)

for(I=0; I<7; I++)
printf("%c ", JOUR[I][0]);

Affectation : pas daffectation directe (genre JOUR [2] = "vendredi" ;). Utiliser strcpy
strcpy(JOUR[4], "Friday");

53

Cours Langages de Programmation

Bibliographie

[1] BEN RHOUMA Ons, HAMDI Omessad, SALEM Faten et ZAYANI Hafeth, "Langages de

Programmation : cours et exercices corrigs", support de cours, ENIT 2004.

[2] Cours M. ELJAMAI Messaoud, M. ZRIBI Amin et Mme SAMAALI Imen , Algorithmique et

structures des donnes : cole Nationale d'ingnieurs de Tunis, ENIT 2010.

[3] Grissa Amel, "Algorithmique et Programmation", support de cours, ENIT 2003.
[4] Claude Delannoy, "Le Livre du C premier langage", dition mars 2002.
[5] Peter Prinz, Ulla Kirch-Prinz, et Philippe Figon, "Syntaxe et fondamentaux du langage C", dition

fvrier 2003.
[6] Claude Delannoy, "Programmer en langage C : Cours et exercices corrigs", Edition avril 2002.

54