Faculté des Sciences

Département d’Informatique

Programmation I

SMA-SMI (S3)

Pr. Samir MBARKI

s.mbarki@uit.ac.ma

2018-2019
 PLAN

1. Introduction au langage C
2. Types composés
3. Pointeurs
4. Fonctions

2
 I - Introduction au langage C

3
 1. Notion de programme
— Rappel:
— Un ordinateur est une machine électronique programmable servant
au traitement de l’information codée sous forme binaire (0 ou 1).
— Comme l'ordinateur a l'avantage d'exécuter très rapidement et sans
erreurs les ordres qu'on lui donne (les instructions), il exécute
beaucoup de traitements complexes plus vite et plus sûrement
qu'un homme.
— Pour donner des ordres à l'ordinateur, il est nécessaire de pouvoir
communiquer avec lui.
— Cette communication passe par un langage de programmation,
dans lequel est écrit le programme.

4
 1. Notion de programme
— Un algorithme représente l'enchaînement des actions
(instructions) nécessaires pour faire exécuter une tâche à un
ordinateur (résoudre un problème).
— Un algorithme s'écrit le plus souvent en pseudo-langage de
programmation (appelé langage algorithmique)
— Un programme est un assemblage et un enchaînement
d’instructions élémentaires écrit dans un langage de
programmation, et exécuté par un ordinateur afin de traiter
les données d’un problème et renvoyer un ou plusieurs
résultats.

5
 1. Notion de programme
— Un algorithme n'est donc exécutable directement par aucune
machine.
— Mais il a l'avantage d'être traduit facilement dans tous les
langages de programmation.

Réflexion
Codage

Problème Algorithme Programme

6
 1. Notion de programme
— L'algorithmique, l'art d'écrire des algorithmes, permet de se
focaliser sur la procédure de résolution du problème sans avoir à se
soucier des spécificités d'un langage particulier.
— Pour résoudre un problème, il est vivement conseillé de réfléchir
d'abord à l'algorithme avant de programmer proprement dit, c'est
à dire d'écrire le programme en langage de programmation.

7
 2. Notion de variables et déclarations
— Les programmes ont pour but de traiter différentes données
afin de produire des résultats.
— Les résultats peuvent eux-mêmes être des données pour
d'autres programmes.

Donnée(s) Programme Résultat (s)

8
 2. Notion de variables et déclarations

— Les données d'un programme doivent être récupérées en

mémoire centrale, à partir du clavier ou d'un fichier par
exemple, pour pouvoir être traitées par le processeur qui
exécute le programme.
— Toutes les données d'un programme sont mémorisées en
mémoire centrale, dans des sortes de cases que l'on appelle
variables.

9
 2. Notion de variables et déclarations
— Une variable peut être représentée par une case mémoire, qui
contient la valeur d'une donnée.
— Chaque variable possède un nom unique appelé
identificateur par lequel on peut accéder à son contenu.
— Exemple : on peut avoir en mémoire une variable prix et une
variables quantité qui contiennent les valeurs 10.2 et 5.

10.2 5

prix quantité
10
 2. Notion de variables et déclarations
— Attention à ne pas confondre la variable et son contenu
— Une variable est un contenant, c'est à dire une sorte de
boîte, alors que le contenu d'une variable est une valeur
numérique, alphanumérique ou booléenne, ou de tout autre
type.
— Deux variables peuvent avoir la même valeur, mais une variable
ne peut pas avoir plusieurs valeurs en même temps (sauf les
types composés).

11
 2. Notion de variables et déclarations
— En revanche, la valeur d'une variable peut varier au cours du
programme.
— L'ancienne valeur est tout simplement écrasée et remplacée par
la nouvelle.
— Les variables dont la valeur ne change pas au cours de
l'exécution du programme sont appelées variables
constantes ou plus simplement constantes.

12
 3. Les bases du langage C
— Le C est un langage compilé (par opposition aux langages
interprétés).
— Cela signifie qu'un programme C est décrit par un fichier
texte, appelé fichier source. Ce fichier n’étant évidemment pas
exécutable par le microprocesseur, il faut le traduire en
langage machine.
— Cette opération est effectuée par un programme appelé
compilateur.
— La compilation se décompose en fait en 4 phases successives :
— Le traitement par le préprocesseur
— La compilation
— L'assemblage
— L'édition de liens
13
 3.1 Jeu de caractères
— 26 lettres de l'alphabet (minuscules, majuscules)
— chiffres 0 à 9
— caractères spéciaux :

! * + \ " <
# ( = | { >
% ) e ; ] /
^ -­‐ [ : , ?
& _ } ' . (espace)

— séquences d'échappement telles :

— passage à la ligne (\n),
— tabulation (\t),
— backspace (\b).
14
 3.2 Identificateurs et mots-clés
— Identificateur : nom donné aux diverses composantes
d'un programme (variables, tableaux, fonctions, …)
— Formé de lettres et de chiffres ainsi que du caractère ‘_’
permettant une plus grande lisibilité.
— Le 1er caractère doit obligatoirement être une lettre ou bien le
caractère ‘_’
— Peut contenir jusqu'à 31 caractères minuscules et majuscules.
— Il est d'usage de réserver les identificateurs entièrement en
majuscules aux variables du préprocesseur.

15
 3.2 Identificateurs et mots-clés
— Exemples :
— Identificateurs valides :
— x   y12   somme_1   _temperature
— noms   surface   fin_de_fichier TABLE
— Identificateurs invalides :
— 4eme commence par un chiffre
— x#y caractère non autorisé (#)
— no-­‐commande caractère non autorisé (-­‐)
— taux  change caractère non autorisé (espace)

16
 3.2 Identificateurs et mots-clés
— Mots réservés (mots-clés) : Un certain nombre de mots,
appelés mots-clefs, sont réservés pour le langage lui-même et ne
peuvent pas être utilisés comme identificateurs.

auto const double float int short

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

17
 3.3 Les commentaires
— Un commentaire débute par /* et se termine par */.
— Exemple :
/*    Ceci  est  un  commentaire  */

— On ne peut pas imbriquer des commentaires.

/*    
Un  commentaire  
/*    Un  autre  commentaire  */
*/

18
 4 La structure d’un programme
— Un programme C est une ou plusieurs fonctions stockées
dans un ou plusieurs fichiers dont l'une doit s'appeler main.
— Une fonction est formée d’un entête (type et nom de la
fonction suivis d'une liste d'arguments entre parenthèses) et
d’instruction composée constituant le corps de la fonction.

19
 4 La structure d’un programme
— Un programme C se présente de la façon suivante :

[directives du préprocesseur]
[déclarations de variables externes]
[fonctions secondaires]
int main(){
déclarations de variables internes
instructions
return 0;
}

20
 4.1 Les directives du préprocesseur
(précompilation)
— Elles commencent toutes par un #.

Commande Signification
#include <stdio.h> permet d’utiliser les fonctions printf() et scanf()
#include <math.h> permet d’utiliser les fonctions mathématiques
#include <conio.h> permet d’utiliser la fonction getch()
#define PI 3.14159 définit la constante PI
#undef PI à partir de cet endroit, la constante PI n’est plus définie
#ifdef PI si la constante PI est définie, on compile les instructions 1,
instructions 1 ... sinon, les instructions 2
#else
instructions 2 ...
#endif

21
 4.2 Les expressions
— Une expression est une suite de composants élémentaires
syntaxiquement correcte.
— Exemple :

x = 0

— ou bien

(i >= 0) && (i < 10) && (p[i] != 0)

22
 4.3 Les instructions
— Une instruction est une expression suivie de ‘;’.
— Le point-virgule signifie en quelque sorte « évaluer cette
expression ».
— Plusieurs instructions peuvent être rassemblées par des
accolades { et } pour former une instruction composée ou
bloc qui est syntaxiquement équivalent à une instruction.
— Exemple :

if (x != 0) {
z = y / x;
t = y % x;
}

23
 4.3 Les instructions
— Une instruction composée d'un spécificateur de type et
d'une liste d'identificateurs séparés par une virgule est une
déclaration.
— Exemple :
int a;
int b = 1, c;
double x = 2.38e4;
char message[80];

— En C, toute variable doit faire l'objet d'une déclaration avant

d'être utilisée.

24
 4.3 Les instructions
— 2.4 Exemple
#include <stdio.h>
#define PI 3.14159
#include <conio.h>
/* calcul de la surface d'un cercle */
main(){
float rayon, surface;
float calcul(float );
printf("Rayon = ? ");
scanf("%f", &rayon);
surface = calcul(rayon);
printf("Surface = %f\n", surface);
getch();
}
/* définition de fonction */
float calcul(float r){
/* définition de la variable locale */
float a;
a = PI * r * r;
return(a);
25 }
 4.5 Les types de base
— Le langage C contient des types de base
— les entiers (int),
— les réels (float) simple et double précision (double)
— et les caractères (char).
— De plus il existe un type ensemble vide : le type void.
— Les mots-clés short et long permettent d'influer sur la
taille mémoire des entiers et des réels.

26
 4.6 Les constantes
— Une constante est une valeur qui apparaît littéralement dans
le code source d'un programme.
— Constantes entières 1, 2, 3, ...
— Constantes caractères ’a’, ’A’, ...
— Constantes chaînes de caractères "Bonjour"
— Pas de constantes logiques
— Pour faire des tests, on utilise un entier. 0 est équivalent à faux
et tout ce qui est ≠ 0 est vrai.

27
 4.7 Les variables
— Les variables peuvent stocker des chiffres des nombres, des
caractères, des chaînes de caractères,… dont la valeur peut
être modifiée au cours de l'exécution du programme.
— Pour déclarer une variable, on fait précéder son nom par son type.
— Exemples de déclarations :
Déclaration Signification
int a ; a est entier
int z=4 ; z est entier et vaut 4
unsigned int x ; x est un entier positif (non signé)
float zx, zy ; zx et zy sont de type réel
float zx=15.15 ; zx est de type réel et vaut 15.15
double z ; z est un réel en double précision
char zz ; zz est une variable caractère
char zz=’a’ ; zz vaut ’a’
28
 4.8 Les opérateurs
— L'affectation (=) : sert à mettre dans la variable de gauche la
valeur de ce qui est à droite.
— Sa syntaxe est la suivante : variable = expression
— Exemple :

main(){
int i, j = 2;
float x = 2.5;
i = j + x;
x = x + i;
printf("%f", x);
}

— imprime pour x la valeur 6.5 (et non 7),

— car dans l'instruction i = j + x;, l'expression j + x a été
convertie en entier.
29
 4.8 Les opérateurs
— Les opérateurs arithmétiques : Les opérateurs
arithmétiques classiques sont l'opérateur unaire -
(changement de signe) ainsi que les opérateurs binaires.

+ Addition
- Soustraction
* Multiplication
/ Division
% reste de la division (modulo)

30
 4.8 Les opérateurs
— Exemple :

float x;
x = 3 / 2;

— affecte à x la valeur 1.
— Par contre :

x = 3 / 2.;

— affecte à x la valeur 1.5.

31
 4.8 Les opérateurs
— Les opérateurs relationnels : servent à comparer deux
expressions

> strictement supérieur

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

— Remarque : Ne pas confondre l’opérateur d’affectation = et

l’opérateur de comparaison ==.
32
 4.8 Les opérateurs
— Exemple :

main() {
int a = 0;
int b = 1;
if (a = b)
printf("\n a et b sont egaux \n");
else
printf("\n a et b sont differents \n");
}

33
 4.8 Les opérateurs
— Les opérateurs logiques booléens :

&& et logique
|| ou logique
! négation logique

— Comme pour les opérateurs de comparaison, la valeur

retournée par ces opérateurs est un int qui vaut 1 si la
condition est vraie et 0 sinon.

34
 4.8 Les opérateurs
— Exemple :

int i;
int p[10];

if ((i >= 0) && (i <= 9) && !(p[i] == 0))

...

— la dernière clause ne sera pas évaluée si i n'est pas entre 0 et 9.

35
 4.8 Les opérateurs
— Les opérateurs d’affectation composée :
+= -= *= /= %= &=
— Exemple :

i+=5 ; /* i=i+5 */
i-=3 ; /* i=i-3 */
i*=4 ; /* i=i*4 */
i/=2 ; /* i=i/2 */
i%=3 ; /* i=i%3 */

36
 4.8 Les opérateurs
— Les opérateurs d’incrémentation ++ et de
décrémentation -- : s'utilisent aussi bien en postfixé
(i++) qu'en préfixé (++i).
— Dans les deux cas la variable i sera incrémentée, toutefois
dans la notation postfixé la valeur retournée sera l'ancienne
valeur de i alors que dans la notation préfixé se sera la
nouvelle.
— Exemple :

int a = 3, b, c;
b = ++a; /* a et b valent 4 */
c = b++; /* c vaut 4 et b vaut 5 */

37
 4.8 Les opérateurs
— L’opérateur virgule : Une expression peut être constituée
d'une suite d'expressions séparées par des virgules :
expression-1, expression-2, ..., expression-n
— Cette expression est alors évaluée de gauche à droite. Sa
valeur sera la valeur de l'expression de droite.
— Exemple :
main(){
int a, b;
b = ((a = 3), (a + 2));
printf("\n b = %d \n",b);
}

— imprime b = 5.
38
 4.8 Les opérateurs
— L’opérateur conditionnel ternaire ? : .

condition ? expression-1 : expression-2

— Cette expression est égale à expression-1 si condition

est satisfaite, et à expression-2 sinon.
— Par exemple, l'expression

x >= 0 ? x : -x

— correspond à la valeur absolue d'un nombre.

39
 4.8 Les opérateurs
— De même l'instruction

m = ((a > b) ? a : b);

— affecte à m le maximum de a et de b.
— Et l’instruction :

d = (a > b) ? ((a>c) ? a : c) : (( b > c) ? b : c);

— affecte à d le maximum de a de b et de c.

40
 4.8 Les opérateurs
— De même l'instruction

m = ((a > b) ? a : b);

— affecte à m le maximum de a et de b.
— Et l’instruction :

d = (a > b) ? ((a>c) ? a : c) : (( b > c) ? b : c);

— affecte à d le maximum de a de b et de c.

41
 4.8 Les opérateurs
— L'opérateur de conversion de type : appelé cast,
permet de modifier explicitement le type d'un objet.
— On écrit :
(type) objet

— Exemple :
main(){
int i = 3, j = 2;
printf("%f \n",(float)i/j);
}
— Affiche la valeur 1.5.
42
 4.8 Les opérateurs
— L’opérateur d’adresse & : appliqué à une variable
retourne l'adresse-mémoire de cette variable.

&objet
— Exemple:

main(){
int i = 3;
printf("i = %d et @i = %d\n", i, &i);
}

— Cela imprime : i = 3 et @i = 57573556

43
 5. Les instructions de contrôle
— Le langage C dispose d’instructions de contrôle permettant de réaliser :
— des choix :
— L’instruction conditionnelle if…else…
— L’instruction d’aiguillage ou de choix switch…case…default…
— des boucles les instruction répétitives :
— while…do…
— do…while…
— for…
— des branchements Les instructions de branchement inconditionnel
— goto
— break ( associé aux boucles)
— continue ( associé aux boucles)
— return

44
 5.1 Les instructions de branchement
conditionnel
— Toute instruction qui permet de contrôler le fonctionnement
d'un programme.
— 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.

45
 5.1.1 Branchement conditionnel
if -- else
— L’instruction conditionnelle if -- else permet de tester une
condition puis d'exécuter une action parmi deux actions possibles.
— La forme la plus générale est celle-ci :
if (expression-1 )
instruction-1
else if (expression-2 )
instruction-2
...
else if (expression-n )
instruction-n
else
instruction-∞

— avec un nombre quelconque de else if ( ... ).

46
 5.1.1 Branchement conditionnel
if -- else
— Le dernier else est toujours facultatif.
— La forme la plus simple est :

if (expression )
instruction

— Chaque instruction peut être un bloc d'instructions.

47
 5.1.2 Branchement multiple
switch
— L’instruction switch est une instruction de choix multiple.
Elle permet d’évaluer une expression puis d'exécuter une action
parmi plusieurs actions étiquetées.
— Si la valeur de l’expression correspond à une des étiquettes,
l’action correspondante est exécutée .
— Sa forme la plus générale est :
switch (expression ){
case constante-1: liste d'instructions 1
break;
case constante-2: liste d'instructions 2
break;
...
case constante-n: liste d'instructions n
break;
default: liste d'instructions ∞
break;
48 }
 5.1.2 Branchement multiple
switch
— « expression » doit être une expression entière
— « la constante » doit être une constante entière( de
type : int, char, short, long, unsigned).
— Par contre « default » est facultatif.
— L’expression est comparée successivement ( de haut en bas)
aux constantes spécifiées après chaque “case”.
— S’il y a égalité, alors les instructions correspondantes à ce
« case » sont exécutées.
— Dans le cas où aucune égalité n’est vérifiée, les instructions
spécifiées après “ default” sont exécutées.
— Pour sortir de l’instruction switch délimitée par { et } et
continuer en séquence, on doit utiliser l’instruction break .
49
 5.1.2 Branchement multiple
switch
— Exemple:
#include <stdio.h>
main(){
int a, b, r;
char op;
printf("Donner deux operandes : ");
scanf("%d %d", &a, &b);
printf("Donner l'operateur : ");
fflush(stdin);
scanf("%c", &op);
switch(op){
case '+' : r = a + b;
printf("%d %c %d = %d\n", a, op, b, r); break;
case '-' : r = a - b;
printf("%d %c %d = %d\n", a, op, b, r); break;
case '*' : r = a * b;
printf("%d %c %d = %d\n", a, op, b, r); break;
case '/' : r = a / b;
printf("%d %c %d = %d\n", a, op, b, r); break;
default : printf("Operateur invalide !!!");
}
}
50
 5.1.3 Les boucles
— Les boucles permettent de répéter une série d'instructions
tant qu'une certaine condition n'est pas vérifiée.
— L’instruction while
— L’instruction do...While...
— L’instruction for

51
 Boucle while
— Tant qu’une condition spécifiée n’est pas vérifiée, elle permet
de répéter une ou plusieurs actions.
— La syntaxe de while est la suivante :

while (expression )
instruction

— Si expression est nulle au départ, instruction ne sera

jamais exécutée.
— instruction peut évidemment être une instruction
composée.

52
 Boucle while
— Par exemple, le programme suivant imprime les entiers de 1
à 9.
i = 1;
while (i < 10){
printf("\n i = %d",i);
i++;
}

53
 Boucle do---while
— Il peut arriver que l'on ne veuille effectuer le test de
continuation qu'après avoir exécuté l'instruction.
— Dans ce cas, on utilise la boucle do---while.
— Sa syntaxe est :

do
instruction
while (expression );

— Ici, instruction sera exécutée tant que expression est non

nulle.
— Cela signifie donc que instruction est toujours exécutée
au moins une fois.
54
 Boucle do---while
— Par exemple, pour saisir au clavier un entier entre 1 et 10 :

int a;
do{
printf("Entrez un entier entre 1 et 10 : ");
scanf("%d",&a);
}while ((a <= 0) || (a > 10));

55
 Boucle for
— L’instruction for est une instruction de boucle faisant
intervenir l’initialisation, le test de limite et l’incrémentation
en une seule action.
— La syntaxe de for est :
for ( expr 1 ; expr 2 ; expr 3)
instruction

— Une version équivalente plus intuitive est :

expr 1;
while (expr 2 ){
instruction
expr 3;
}
56
 Boucle for
— Par exemple, pour imprimer tous les entiers de 0 à 9, on
écrit :
for (i = 0; i < 10; i++)
printf("\n i = %d",i);

— A la fin de cette boucle, i vaudra 10.

57
 5.2 Les instructions de branchement
non conditionnel break, continue et goto
— Le langage C propose plusieurs instructions qui permettent
d'altérer le contrôle de boucles itératives, soit en forçant le
programme à passer à l'itération suivante sans finir d'exécuter
les instructions correspondant à celle qui est en cours, soit en
forçant le programme à quitter la boucle, comme si la
condition était fausse.
— C'est dans cet ordre que nous étudierons ces instructions
d'altération de répétitives.

58
 5.2.1 break
— Permet d'interrompre 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.

59
 5.2.1 break
— Exemple :
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);
}
— le programme imprime à l'écran

i=0
i=1
i=2
i=3
60
valeur de i a la sortie de la boucle = 3
 5.2.2 continue
— L'instruction continue permet de passer directement au tour de
boucle suivant, sans exécuter les autres instructions de la boucle.
— Exemple :
main(){
int i;
for (i = 0; i < 5; i++){
if (i == 3)
continue;
printf("i = %d\n",i);
}
printf("valeur de i a la sortie de la boucle = %d\n",i);
}
i=0
— Le programme imprime i=1
i=2
i=4
61 valeur de i a la sortie de la boucle = 5
 II - Les types composés

66
 1 Introduction
— A partir des types prédéfinis du langage C (caractères,
entiers, flottants), on peut créer de nouveaux types, appelés
types composés :
— Tableau
— Structure
— Union
— Enumération, ...).
— Les types composés permettent de représenter des
ensembles de données organisées.

67
 2 Les tableaux
— Tableau : ensemble fini d'éléments de même type, stockés
en mémoire à des adresses contiguës.
— Déclaration : tableau à une dimension :

Type nomTableau[nombreElements];

— Exemple :
float tabR[5];      /*  tableau  de  5  flottants  (réels).  */
int tabE[8]; /* tableau de 8 entiers. */

68
 2 Les tableaux
— Recommandation : Donner un nom à la constante
nombreElements par une directive au préprocesseur.
— Exemple :

#define nombreElements 10

— L'opérateur [] permet l’accès à un élément du tableau.

— Les éléments d'un tableau sont toujours numérotés de 0 à
nombreElements-­‐1.

69
 2 Les tableaux
— Exemple :

#define N  10
main(){
int tab[N];
int i;
...
for (i =  0;  i <  N;  i++)
printf("tab[%d]  =  %d\n",  i,  tab[i]);
}

70
 2 Les tableaux
— Un tableau correspond à un pointeur constant (voir les
pointeurs) vers le premier élément du tableau.
è aucune opération globale n'est autorisée sur un tableau.
tab1 = tab2;

è Effectuer l'affectation pour chacun des éléments du tableau :

#define N  10
main(){
int tab1[N],  tab2[N];
int i;
...
for (i =  0;  i <  N;  i++)
tab1[i]  =  tab2[i];
}
71
 2 Les tableaux
— On peut initialiser un tableau lors de sa déclaration par une
liste d’éléments :
— Exemple :
#define N  4
int tab[N]  =  {11,  22,  33,  44};
main(){
int i;
for  (i =  0;  i <  N;  i++)
printf("tab[%d]  =  %d\n",  i,  tab[i]);
}

tab[0] = 11
tab[1] = 22
tab[2] = 33
tab[3] = 44
72
 2 Les tableaux
— Un tableau de caractères = Chaîne de caractères
— Initialisation :
char p1[10]  =  ’B’,’o’,’n’,’j’,’o’,’u’,’r’;
char p2[10]  =  "Bonjour";      /*  init.  par  une  chaîne  litterale */
char p3[]  =  "Bonjour";          /*  p3  aura  alors  8  éléments              */

Le compilateur rajoute toujours un caractère ‘\0’ à la fin

d’une chaîne de caractères.
èIl faut donc que le tableau ait au moins un élément de plus.

73
 3 Les tableau à n-dimensions
— On peut déclarer un tableau à plusieurs dimensions.
— Exemple : Tableau à 2 dimensions
Type nomTableau [nombreLignes][nombreColonnes];

— Tableau à 2D = Tableau 1D de tableau 1D.

— L’accès à un élément : nomTableau[i][j]

74
 3 Les tableau à n-dimensions
— On peut initialiser un tableau à plusieurs dimensions à la
compilation par une liste dont chaque élément est une liste
de constantes.
#define M  2
#define N  3
int tab[M][N]  =  {{1,  2,  3},  {4,  5,  6}};
main(){
int i,  j;
for  (i =  0  ;  i <  M;  i++){
for  (j  =  0;  j  <  N;  j++)
printf("%d\t",  tab[i][j]);
printf("\n");
}
}

1 2 3
75 4 5 6
 4 Les types énumérés
— Permettent de définir un type par une liste de valeurs qu'il peut
prendre.
— Défini par le mot clé enum et un identificateur de modèle, suivis
d’une liste de valeurs.
enum modele {constante1,  constante2,  ...,  constanten};

— Les valeurs possibles constante1, constante2, ...,

constanten sont codées par des entiers de 0 à n-­‐1.
— Exemple : (Type booleen)
enum booleen {faux,  vrai};
main(){
enum booleen b;
b  =  vrai;
printf("b  =  %d",  b);
}

76 b = 1
 4 Les types énumérés
— On peut modifier le codage par défaut des valeurs de la liste
d’une énumération lors de la déclaration.
— Exemple :
enum booleen {faux =  12,  vrai =  23};

77
 5 Les structures
— Structure : agrégat de plusieurs objets de types différents
regroupés dans une même variable.
— Une donnée composant une structure = un champ ou attribut
— Un champ peut être de types quelconques
— Type simple,
— Tableaux,
— Autres structures,
— …
— Les champs possèdent un identificateur qui permet d’accéder
directement à la donnée qu’ils contiennent.

78
 5 Les structures
— Exemple :
Pour un étudiant, on peut regrouper dans une seule variable :
— son nom (chaîne de caractères),
— son prénom (chaîne de caractères),
— son âge (entier),
— son sexe (masculin ou féminin),
— son numéro CNE (tableau de 10 chiffres), ...

79
 5 Les structures
— Déclaration d'un modèle de structure
struct modele{
type1  membre1;
type2  membre2;
...
typen membren;    
};

— Déclaration d’une variable de type structure :

struct modele objet;

— Ou bien :
struct modele{
type1  membre1;
type2  membre2;
...
typen membren;    
}    objet;
80
 5 Les structures
— Exemples:
— Une structure de nom Etudiant correspondant à un étudiant :
enum genres  {Feminin,  Masculin};

struct Etudiant  {
char nom[20],  prenom[20];
int age;
enum genres  genre;
int numero[5];
}  element =  {"Aissaoui",  "Ali",  22,  Masculin,  
{02,49,11,39,42}};

81
 5 Les structures
— Exemples:
— Une structure Point correspondant à un point de coordonnées
x, y dans un plan.
struct Point  {  
int x;  
int y;  
};

— Une structure de nom Adresse possible pour coder une adresse

postale :
struct Adresse  {  
int num;  
char rue[40];  
long code;  
char ville[20],  pays[20];  
};
82
 5 Les structures
— Exemples:
— Une structure de nom Individu dont l'un des champs a la
structure Adresse précédente (dont la définition est supposée
connue) et contenant la définition d'une structure interne
anonyme pour le champ de nom Identite :
struct Individu{  
struct {  
char nom[20];  
char prenom[20];  
}  Identite;  
int age;  
struct Adresse  domicile;  
};

83
 5 Les structures
— Le C permet de créer des alias sur une structure avec typedef :

typedef struct {  
int a,  b;                                //  a  et  b  dans  la  même  déclaration  
}  couple;

— On accède aux différents membres (champs) d'une structure

grâce à l'opérateur membre de structure, noté ".".
nomObjet.nomChamp

84
 5 Les structures
— Remarque :

— L’affectation globale au moyen de l’opérateur = entre deux objets de

même structure est maintenant autorisée par la plupart des
compilateurs.
struct Complexe  z1,  z2;
...
z2  =  z1;

— La comparaison (==) n’est par contre pas admise généralement. Il est

nécessaire de tester chacun des champs l’un après l’autre.

— Les règles d'initialisation d'une structure lors de sa déclaration sont les

mêmes que pour les tableaux:
struct Complexe  z  =  {2.  ,  2.};
85
 5 Les structures
— Exemple 1 :
#include <math.h>
struct Complexe{
double reelle;
double imaginaire;
};
main(){
struct Complexe  z  =  {3.5,  2.9};
double norme;
norme  =  sqrt(z.reelle *  z.reelle +  
z.imaginaire *  z.imaginaire);

printf("La  norme  de  (%.2f  +  i  %.2f)  =  %.2f\n",  

z.reelle,  z.imaginaire,  norme);
}

La norme de (3.50 + i 2.90) = 4.55

86
 5 Les structures
— Exemple 2 :
enum propulsion  {pedales,  moteur,  reacteur};
struct vehicule {
char nom[20];
int longueur,  poids;
enum propulsion  mode;
}  velo =  {"Euroteam",  2,  5,  pedales};
main ()  {
struct vehicule voiture  ={"Toyota",  5,  1500,  moteur };
struct vehicule avion;
printf ("Nom:  %s\n",  velo.nom);
printf ("Longueur:  %d,  poids:  %d\n",  velo.longueur,  velo.poids);
printf("Mode  de  propulsion:  %d",  velo.mode); printf ("\n");
strcpy(avion.nom,  "Jumbo");    avion.longueur =  60;
avion.poids =  450000; avion.mode =  reacteur;
printf ("Nom:  %s\n",  avion.nom);
printf ("Longueur:  %d,  poids:  %d\n",  
avion.longueur,  avion.poids);
printf("Mode  de  propulsion:%d\n",  avion.mode);
87 }
 5 Les structures
— Exemple 2 :
Nom: Euroteam
Longueur: 2, poids: 5
Mode de propulsion: 0
Nom: Jumbo
Longueur: 60, poids: 450000
Mode  de  propulsion:2

88
 6 Les champs de bits
— Possible de spécifier la longueur des champs d'une structure au
bit près si ce champ est de type entier.
— Exemple :
— La structure Registre possède deux membres, actif codé sur un
seul bit, et valeur codé sur 31 bits:
struct Registre{
unsigned int actif :  1;
unsigned int valeur :  31;
};

— Tout objet de type struct Registre est donc codé sur 32 bits.

89
 7 Les unions
— union désigne un ensemble de variables de types différents
susceptibles d'occuper alternativement une même zone
mémoire.
— Si les membres d'une union sont de longueurs différentes, la
place réservée en mémoire pour la représenter correspond à
la taille du membre le plus grand.
— Déclarations et opérations sur union sont les mêmes que
struct.

90
 7 Les unions
— Exemple :
— La variable hier de type union Jour peut être soit un entier,
soit un caractère.
union Jour{
char lettre;
int numero;
};
main(){
union Jour  hier,  demain;
hier.lettre =  'J';
printf("Hier  =  %c\n",  hier.lettre);
hier.numero =  4;
demain.numero =  (hier.numero +  2)  %  7;
printf("Demain  =  %d\n",  demain.numero);
}

Hier = J
91 Demain  =  6
 8 Définition de types composés avec
typedef
— Pour alléger l'écriture, on peut affecter un nouvel identificateur
à un type composé à l'aide de typedef :
— Exemple 1 :

struct Eleve{
char nom[20]; Eleve 1 : Alaoui Hamza 17.00
char prenom[20]; Eleve 2  :  Hatimi Bouchra 13.00
float note;
};
typedef struct Eleve Eleve;
main(){
Eleve a  =  {"Alaoui",  "Hamza",  17},  b;
strcpy(b.nom,  "Hatimi");      strcpy(b.prenom,  "Bouchra");
b.note =  13;
printf("Eleve 1  :  %s  %s  %.2f\n",  a.nom,  a.prenom,  a.note);
printf("Eleve 2  :  %s  %s  %.2f\n",  b.nom,  b.prenom,  b.note);
}
92
 8 Définition de types composés avec
typedef
— Exemple 2 : -­‐-­‐-­‐-­‐-­‐-­‐ Saisie -­‐-­‐-­‐-­‐-­‐-­‐
struct Eleve{ Eleve 1 : Hachimi Souad 16
char nom[20]; Eleve 2 : Alami Brahim 13
char prenom[20]; Eleve 3 : Hamdi Merieme 14
float note; -­‐-­‐-­‐-­‐-­‐-­‐ Affichage -­‐-­‐-­‐-­‐-­‐-­‐
}; Eleve 1 : Hachimi Souad 16.00
typedef struct Eleve Eleve; Eleve 2 : Alami Brahim 13.00
typedef Eleve TabEleve[100]; Eleve 3  :  Hamdi Merieme 14.00
main(){
TabEleve T;        int i;
printf("-­‐-­‐-­‐-­‐-­‐-­‐ Saisie -­‐-­‐-­‐-­‐-­‐-­‐\n");
for(i=0;i<3;i++){
printf("Eleve %d  :  ",  i+1);  
scanf("%s  %s  %f",  T[i].nom,  T[i].prenom,  &T[i].note);
}
printf("-­‐-­‐-­‐-­‐-­‐-­‐ Affichage -­‐-­‐-­‐-­‐-­‐-­‐\n");
for(i=0;i<3;i++)
printf("Eleve %d  :  %s  %s  %.2f\n",  
i+1,  T[i].nom,  T[i].prenom,  T[i].note);
}
93