1 of 28

CHAPITRE 4�� LANGAGE DE � PROGRAMMATION: C

F. Karami

2 of 28

Plan

Les Types Dérivés

Les Fonctions

*

Programmer en langage C

2

3 of 28

Les Types Dérivés

Les Enumération

2) Les Tableaux

3) Les Structures

4) Les Unions

*

Programmer en langage C

3

4 of 28

1- Les énumérations

Les énumérations permettent de définir un type pour des variables qui ne sont affectées qu’a un nombre fini de valeurs. Un objet de type énumération est défini par le mot-clef enum et un identificateur de modèle, suivi de la liste des valeurs que peut prendre cet objet :

enum modele {constante₁, constante₂,. . . ,constante_n} ;

En réalité, les objets de type enum sont représentés comme des int. Les valeurs possibles constante₁, constante₂,. . . ,constante_n sont codées par des entiers de 0 à n-1.

*

Programmer en langage C

4

Les types dérivés

5 of 28

Les énumérations

Le type enum boolean, Dans l’exemple suivant, associe l’entier 0 à la valeur FALSE et l’entier 1 à la valeur TRUE.

#include <stdio.h>

enum boolean {FALSE, TRUE};

main () {

enum boolean b1 = TRUE;

printf("b = %d\n",b1);

system(« pause »);

}

*

Programmer en langage C

5

Les types dérivés

6 of 28

Les Tableaux

*

Programmer en langage C

6

Les types dérivés

7 of 28

2- Les tableaux

Il est souvent nécessaire de mémoriser un grand nombre d’éléments identiques. Il serait par exemple fastidieux de déclarer 1000 variables réelles représentant 1000 valeurs. Pour cela on utilise des tableaux.
Définition

Un tableau représente un ensemble d’emplacements mémoire qui portent le même nom et contiennent le même type de données. Chacun de ces emplacements est un éléments du tableau.
On appelle tableau une variable composée de données de même type, stockée de manière contiguë en mémoire(les uns à la suite des autres).
Un tableau est une suite des éléments de même taille. Par conséquent, la taille(en octet) du tableau est :

type de donnée*le nombre d’éléments.

*

Programmer en langage C

7

Les types dérivés

8 of 28

Les tableaux

Les tableaux à une dimensions

Un tableau à une dimension ne possède qu’un index. Un index est le nombre entre crochets qui suit le nom du tableau. Il indique le nombre d’éléments du tableau.
Déclarations

<type simple> Nom_du_tableau[nombre_elements];

Type simple : définit le type d’élément que contient le tableau
Nom du tableau : est le nom qu’on donne au tableau, ce nom suit les mêmes règles qu’un nom de variable.
Nombre_elements : est une expression constante entière positive, qui exprime la taille du tableau.

Exemple:

char caractere[12];
int entier[10];
float reel[8];

*

Programmer en langage C

8

Les types dérivés

9 of 28

Les tableaux

Les tableaux à une dimensions

Initialisation à la déclaration

Il est possible d’initialiser le tableau à la définition :

<type > Nom_du_tableau[nombre_elements]={c1,c2,…cn};

Ou c1, c2,…cn sont des constantes dont le nombre ne doit pas dépasser le nombre _elements.

Exemple

#define N_mois 12

int tableau[N_mois];

int tab[4] ={100,200,300,400;}\\ initialisation

char voyelles[6]={‘a’,’e,’i’,’o’,’u’,’y’};

*

Programmer en langage C

9

Les types dérivés

10 of 28

Les tableaux

Les tableaux à une dimensions

Accès aux composantes d’un tableau

Pour accéder à un élément du tableau, il suffit de donner le nom du tableau, suivi de l’indice de l’élément entre crochets :

Nom_du_Tableau [indice]

Où indice est une expression entière positive ou nulle.
Un indice est toujours positif ou nul ;
L’indice du premier élément du tableau est 0 ;
L’indice du dernier élément du tableau est égal au nombre d’éléments – 1.

Exemples :

short A[5] = {12 , 23 , 34 , 45 , 56}; // A[0] = 12 ; A[1] = 23 ; A[2] = 34 ;

// A[3] = 45 ; A[4] = 56 ;

for( i = 0 ; i< 5 ; i++ ) //Affichage des éléments

printf(‘’A[%d] = %d \t‘’,i,A[i]); // du tableau A

*

Programmer en langage C

10

Les types dérivés

11 of 28

Les tableaux

Les tableaux à une dimensions

Remarque

Chaque élément ( TAB[i] ) d’un tableau ( int TAB[20] ) est manipulé comme une simple variable, on peut :

la lire : scanf("%d", &TAB[i] ); // TAB[i] sera initialisé par un

// entier saisi depuis la clavier

l’écrire : printf("TAB[%d] = %d", i , TAB[i] ); //Le contenu de TAB[i]

//sera affiché sur écran

la passer en argument à une fonction : TAB[i] = pow(TAB[i],2);

// = TAB[i] ²

Pour initialiser un tableau (TAB1) par les éléments d’un autre tableau (TAB2) : évitez d’écrire TAB1 = TAB2 (incorrect)
On peut par exemple écrire :

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

TAB1[i] = TAB2[i];

�

*

Programmer en langage C

11

Les types dérivés

12 of 28

Les tableaux 2D

Les tableaux à deux dimensions

En C, un tableau multidimensionnel est considéré comme un tableau dont les éléments sont eux même des tableaux.

Un tableau à deux dimensions se déclare donc de la manière suivante :

int mat[10][20];

En faisant le rapprochement avec les mathématiques, on peut dire que mat est une matrice de 10 lignes et de 20 colonnes.

*

Programmer en langage C

12

Les types dérivés

13 of 28

Les tableaux 2D

Les tableaux à deux dimensions

On accède à un élément du tableau par l’expression mat[i][j].
Pour initialiser un tableau à plusieurs dimensions à la compilation, on utilise une liste dont chaque élément est une liste de constantes :

#include <stdio.h>

#define L 3 //nombre de lignes

#define C 2 //nombre de colonnes

int tab[L][C] = {{1, 2}, {14, 15}, {100, 200}};

main() {

int i, j;

for (i = 0 ; i < L; i++) {

for (j = 0; j < C; j++)

printf("tab[%d][%d]=%d\n",i,j,tab[i][j]);}}

*

Programmer en langage C

13

Les types dérivés

14 of 28

Les tableaux

Modification des éléments d’un tableau passé en paramètre

#include <stdio.h>

void print_tab(int tab[], int nb_elem) {...}

/* incrémente chaque composantes du tableau */

void incr_tab(int tab[], int nb_elem) {

int i;

for (i=0; i < nb_elem; i++) tab[i]++;}

#define TAILLE 4

main() {

int t[TAILLE] = {1, 2, 3, 4};

incr_tab(t, TAILLE);

print_tab(t, TAILLE);

}

*

Programmer en langage C

14

Les types dérivés

15 of 28

Les Structures

*

Programmer en langage C

15

Les types dérivés

16 of 28

3-Les structures

Une structure est une suite finie d’objets de types différents. Qui sont regroupé au sein d’une même entité.
Contrairement aux tableaux, les différents éléments d’une structure n’occupent pas nécessairement des zones contiguës en mémoire.
Chaque élément de la structure, appelé membre ou champ, est désigné par un identificateur.

struct enreg {

int numero;

int qte;

float prix;

};

*

Programmer en langage C

16

Les types dérivés

17 of 28

Les structures

L’utilisation pratique d’une structure se déroule de la façon suivante :

On commence par déclarer la structure elle-même. Le modèle général de cette déclaration est le suivant :

struct nom_structure {

type_1 membre_1 ;

type_2 membre_2 ;

...

type_n membre_n ;

} ;

*

Programmer en langage C

17

Les types dérivés

18 of 28

Les structures

2. Pour déclarer un objet de type structure correspondant au modèle

précédent, on utilise la syntaxe :

struct nom_structure identificateur_objet ;

Ou bien, si le modèle n’a pas encore été déclaré au préalable :

struct nom_structure {

type_1 membre_1 ;

type_2 membre_2 ;

...

type_n membre_n ;

} identificateur_objet ;

3. On accède aux différents membres d’une structure grâce à

l’opérateur membre de structure, noté ”.”. Le i-ème membre de objet

est désigné par l’expression :

identificateur_objet.membre_i

*

Programmer en langage C

18

Les types dérivés

19 of 28

Les structures

Chaque champ d’une structure peut être manipulé comme n’importe quelle variable de type correspondant. Voici quelques exemples utilisant la structure enreg:

struct enreg art1,art2; /* déclaration*/
art1.numero=15; /*affectation*/
printf(‘’%f’’,art1.prix); /* affiche la valeur du champ prix*/
scanf(‘’%f’’,&art2.prix); /*lit une valeur qui sera affecté

au champ prix de la structure art2 */

art1.numero++; /* incrémente de 1 la valeur du champ

numero de la structure art1*/

*

Programmer en langage C

19

Les types dérivés

20 of 28

Les structures

Il possible d’affecter à une structure le contenu d’une structure définie à partir du même modèle. Par exemple nous pouvons écrire:

art1=art2;

Une telle affectation remplace :

art1.numero = art2.numero;
art1.qte = art2.qte;
art1.prix = art2.prix;

Initialisation d’une structure au moment de sa déclaration :

struct enreg art1={100,290,3000};

*

Programmer en langage C

20

Les types dérivés

21 of 28

Les structures

structure comportant des tableaux:

struct personne{ char nom[30];

char prenom[20];

float heures[31];

} employe, courant;

/*heures: nbre d’heures du travail dans chaque jours du mois*/

employe.heures[4]; /*5^ème éléments du tableau heures*/
employe.nom[0]; /* premier caractère du champ nom*/

Initialisation:

struct personne courant={‘’Dupont’’, ‘’julea’’}

*

Programmer en langage C

21

Les types dérivés

22 of 28

Les structures

Tableaux de structures

struct point { char nom;

int x;

int y;

};

struct point courbe[50];

Cette structure sert à représenter un point d’un plan qui serait défini par son nom(caractère) et ses deux coordonnées.
courbe[i].nom; courbe[i].x; courbe[i].y; /*représente le nom du point de rang i, la valeur du champ x et la valeur du champ y*/
Initialisation :

struct point courbe[50]={{‘A’,10,25},{‘M’,13,34},{‘R’,2,6}};

*

Programmer en langage C

22

Les types dérivés

23 of 28

Les structures

Structures comportant d’autres structures:

Supposant que l’intérieur de la structure employe et courant nous ayant besoin d’introduire deux dates: la date d’embauche et la date d’entrée. Si ces dates sont elles-mêmes des structures comportant trois champs correspondant au jour et à l’année, nous pouvons alors procéder aux déclarations suivantes :

struct date { int jour;

int mois;

int annee;};

struct personne{ char nom[30];

char prenom[20];

float heures[31];

struct date date_embauche;

struct date date_poste;

} employe, courant;

*

Programmer en langage C

23

Les types dérivés

24 of 28

Les structures

La notation :

employe.date_embauche.annee

Représente l’année d’embauche correspondant à la structure employe. Il s’agit d’une valeur de type int.

courant.date_embauche

Représente la date d’embauche de la structure courant, et nous pouvons faire l’affectation:

courant.date_embauche=employe.date_poste;

*

Programmer en langage C

24

Les types dérivés

25 of 28

Les structures

Exercice:

Ecrire un programme qui lit au clavier des informations dans un tableau de structure du type point défini comme suit:

struct point{

int num;

float x;

float y;

}

Le nombre d’éléments du tableau sera fixé par une instruction #define.

Affiche à l’écran l’ensemble des informations précédentes?

*

Programmer en langage C

25

Les types dérivés

26 of 28

4- Les unions

Il est parfois nécessaire de manipuler des variables auxquelles on désire affecter des valeurs de type différents. Supposons que l'on désire écrire un package mathématique qui manipulera des nombres qui seront implémentés par des int, tant que la précision des entiers de la machine sera suffisante et qui passera automatiquement à une représentation sous forme de flottants dès que ce ne sera plus le cas. Il sera nécessaire de disposer de variables pouvant prendre soit des valeurs entières, soit des valeurs flottantes. Ceci peut se réaliser en C, grâce au mécanisme des unions.

*

Programmer en langage C

26

Les types dérivés

27 of 28

Les unions

Une définition d'union à la même syntaxe qu'une définition de structure, le mot clé struct étant simplement remplacé par le mot clé union.
Exemple:

union partage{

char c;

int i;

}

union nombre{

int i;

float f;

}

*

Programmer en langage C

27

Les types dérivés

28 of 28

Les unions

on déclarera une variable p de type union partage par :

union partage p;

cette variable pourra posséder soit une valeur entière, soit un caractère, mais pas les deux à la fois.

on déclarera une variable n de type union nombre par

union nombre n;

cette variable pourra posséder soit une valeur entière, soit une valeur flottante, mais pas les deux à la fois.

*

Programmer en langage C

28

Les types dérivés