Vous êtes sur la page 1sur 14

Page - 1

Chapitre 6 : Les types composé s

Table of Contents
I. Les tableaux unidimensionnels ....................................................................................................... 2
1. Déclaration .................................................................................................................................. 2
2. Accès aux composantes d’un tableau ......................................................................................... 2
3. Initialisation ................................................................................................................................. 3
4. Taille d’un tableau ....................................................................................................................... 4
5. Affichage du contenu d’un tableau ............................................................................................. 4
6. Passage d’un tableau comme paramètre.................................................................................... 5
II. Tableau à deux dimensions ............................................................................................................. 5
1. Déclaration .................................................................................................................................. 5
2. Accès aux composantes d’une matrice ....................................................................................... 6
3. Transmission d’un tableau à deux dimensions à une fonction ................................................... 6
III. Le structures ................................................................................................................................ 7
1. Syntaxe ........................................................................................................................................ 7
2. Accès aux membres de structures .............................................................................................. 8
3. Initialisation ................................................................................................................................. 8
4. Les structures plus complexes ..................................................................................................... 9
a) Les structures imbriquées ....................................................................................................... 9
b) Les tableaux membres des structures ..................................................................................... 9
c) Tableaux de structures ............................................................................................................ 9
IV. Les énumérations ...................................................................................................................... 10
1. Définition des types énumérés.................................................................................................. 10
2. Conversion des types énumérés ............................................................................................... 11
V. Les unions ...................................................................................................................................... 11
VI. Définition de type ...................................................................................................................... 13
1. Cas des types simples ................................................................................................................ 13
2. Cas des types tableau ................................................................................................................ 13
3. Cas des types énumérés ............................................................................................................ 13
4. Cas des structures ..................................................................................................................... 13

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021


Page - 2

I. Les tableaux unidimensionnels


Un tableau est une structure de données constituée d’un nombre fini d’éléments de même type.
Lorsque plusieurs données de même type, généralement destinées au même traitement doivent
être accessibles le long d’un programme, on propose d’utiliser la structure d’un tableau pour les
stocker.

…………………..

N composantes

Un tableau est défini par :


- Son Nom : identificateur d’un tableau.
- Le type de ses éléments : Les éléments d’un tableau sont caractérisés par leur type (entier, réel,
caractère,……..).

1. Déclaration

type_elt nom_tab [nombre_elt] ;


Exemples :
int T1[50] : déclare un tableau T1 de taille maximale 50 entiers.
float T2[20] : déclare un tableau T2 de taille maximale 20 nombre flottant.
char T3[20] : déclare un tableau T2 de taille maximale 20 caractères.

2. Accès aux composantes d’un tableau


Considérons un tableau T de dimension N
• L’accès au premier élément du tableau se fait par T[0]
• L’accès au ième élément du tableau se fait par T[i-1]
• L’accès au dernier élément du tableau se fait par T[N-1]
Exemple :
Nom : T
100 200 300 400 500 600
Indice 0 1 2 3 4 5
Contenu : T[0] T[1] T[2] T[3] T[4] T[5]

Remarques :
• Les numéros des éléments d’un tableau de n éléments vont de 0 à n-1.
• Une tentative d’accès à une case d’indice ≥ n provoquera un résultat aléatoire et risque
en particulier de provoquer une segmentation fault.
• En C, le nom d’un tableau est le représentant de l’adresse du premier élément du tableau.
Ex. La notation tab est équivalente à &tab[0].

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021


Page - 3

3. Initialisation
• statique « type » « nom » [« taille »]={ « liste de valeurs » } ;
 int toto[10] = {12,8,23,24,6,8,19,20,9,4} ;
 int toto[] = {12,8,23,24,6,8,19,20,9,4} ; //tableau de 10
entiers ==> réservation de 10*sizeof(int) octets
 int toto[10] = {12,8,23} ; // le reste des éléments sont
initialisés à zéro ou aléatoirement
• dynamique « par des affectations aux éléments »
 int toto[10] ;
toto[0]=12 ;
toto[1]=8 ;
toto[2]=23 ;
...
toto[9]=4 ;

Exemple :

#define TAILLE 100


...
int i;

int tab1[TAILLE];

char tab2[20];

short tab3[] = {0,1,2,3,4,5,6,7,8,9}; /* taille = 10 */

double tab4[]={12.2,3.0,8.1,4.777}; /* taille = 4 */

char mot[] = "Toto";


char toto[] = {’T’,’o’,’t’,’o’,’\0’} ;

int n = 8;
for(i=0; i<=TAILLE-1; i++)
tab1[i]=i*n;

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


tab2[i] = ‘a’+i;

Remarque:
Si un tableau est formé de N composantes et si une composante a besoin de M octets en mémoire,
alors le tableau occupera de N*M octets.

Exemple : En supposant qu'une variable du type long occupe 4 octets (c’est à


dire: sizeof(long)=4), pour le tableau T déclaré par: long T[15];
 C réservera N*M = 15*4 = 60 octets en mémoire.

Remarque: Ces instructions sont interdites :


 int ttt[]; //array size is missing
 int tt[5] ;
o tt[5]={1, 2, 3, 4, 5}; //expected expression before '{'
token
o tt = {1, 2, 3, 4, 5}; //expected expression before '{'
© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021
Page - 4

token
 tt = tab2; //assignment to expression with array type
 short tab3[]={0,1,2,3,4,5,6,7,8,9};
o short t[] = tab3; //invalid initializer
 char mot [] = "happy";
o mot = "excited"; //assignment to expression with array
type

4. Taille d’un tableau


La taille d’un tableau est connue à la compilation : c’est une constante ou bien un nombre.
Ok Mauvaise déclaration, n n’est pas constante
Exemple :
(accepté en C99)
#define TAILLE 50 void main()
void main() {
{ int n = 50 ;
double tab1[TAILLE] ; double tab[n];
int tab2[5]; …
short tab3[2*TAILLE]; }

}

5. Affichage du contenu d’un tableau


• On parcourt et on affiche les éléments du tableau :
#include<stdio.h>
void main()
{
int T[5], i ;
for (i=0 ; i<5 ; i++){
printf("%d\t", T[i]) ;
}
}

• Dans le cas d’une chaîne de caractères : soit on connaît sa taille et on peut procéder de même ; soit
on utilise ’\0’ pour stopper le parcours (dernier caractère d’une chaîne de caractères).

Exemple 1 :
char mot[] = "happy";
for(i=0; mot[i]!=’\0’; i++)
putchar(mot[i]);

Exemple 2 :

char toto [] = {'T','o','t','o','\0'} ;


i = 0;
while(toto[i] != '\0'){
putchar(toto[i]);
i ++;
}

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021


Page - 5

6. Passage d’un tableau comme paramètre

Le passage d'un tableau comme paramètre d'une fonction est impossible en tant que valeur : la recopie
du tableau prendrait trop de temps et de place. On passe donc à la fonction l'adresse du tableau, ce qui
permettra à la fonction d'effectuer des lectures et des écritures directement dans le tableau.

Pour transmettre l'adresse du tableau à une fonction, il suffit de lui donner le nom du tableau :

nom_fct( nom_tableau, ... ) ; /* appel de fonction avec argument tableau */

L’entête d’une fonction qui prend en argument un tableau peut être :


nom_fonction(int T[9]); /* si on connait la taille du tableau*/
nom_fonction(int *T); /*avec la notion de pointeur*/
nom_fonction(int T[], …); /* le compilateur n’a pas besoin de
connaître la taille du tableau, ça nous
permet de travailler sur un tableau de taille
quelconque, la taille du tableau doit être
passée en paramètre.*/

II. Tableau à deux dimensions


• Un tableau à deux dimensions A est interprété comme un tableau (unidimensionnel) de
dimension L dont chaque composante est un tableau (unidimensionnel) de dimension C.
• Matrice = Tableau dont les cases sont des tableaux.

On appelle L le nombre de lignes du tableau et C le nombre de colonnes du tableau.


Un tableau à deux dimensions contient L*C composantes.
Un tableau de dimensions L et C, formé de composantes dont chacune a besoin de M octets,
occupera L*C*M octets en mémoire.

……. …… …… …… L Lignes

C colonnes

1. Déclaration
type_élément Nom_tab [nbre_lignes][nbre_col] ;

Exemples :
int M1[30][50] ; //déclare une matrice de 30 lignes et 50 colonnes d’entiers.
float M2[20][20] ;
char M3[10][10] ;

• Comme pour un tableau classique, on indique sa taille lors de la déclaration :


© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021
Page - 6

o int matrice[2][3];
• Comme pour un tableau classique, on peut l’initialiser :
o lors de la déclaration :
 int matrice[2][3] = {{ 1 , 2 , 3 }, { 4 , 5 , 6 } };
o ou après la déclaration
 matrice[0][0] = 1;
matrice[0][1] = 2;
matrice[0][2] = 3;
matrice[1][0] = 4;…

2. Accès aux composantes d’une matrice


• Considérons un tableau M de L lignes et C colonnes.
• Les indices du tableau varient de 0 à L-1, respectivement de 0 à C-1.
• Pour accéder à la 1ère composante : A[0][0].
• Plus généralement : <Nom du tableau>[<ligne>][<colonne>]

3. Transmission d’un tableau à deux dimensions à une fonction


La transmission d'un tableau à plusieurs dimensions en paramètre à une fonction s'effectue comme
pour les tableaux à une dimension, à une exception près.
La seule différence est que seule la dimension la plus à gauche peut être omise dans l'en‐tête ou le
prototype de la fonction.
Exemple :
void remplissage(int M[][NB_COL], int n) ; /*ici, on a enlevé le nombre de
lignes, le nombre de colonnes doit être déclarée au préalable*/

Remarque :
• Comme pour les tableaux à une dimension, le nom d’une matrice est le représentant de
l’adresse du premier élément du tableau (l’adresse de la première ligne du tableau).
• Les composantes d’un tableau à deux dimensions sont stockées ligne par lignes dans la
mémoire.

Exemple :
int A[3][2] = { {1,2}, {10,20}, {100,200} };

Exemple : affichage du contenu d’une matrice


#include<stdio.h>
void main()
{
int T[5][6], i , j;
for (i=0 ; i<5 ; i++){
for (j=0; j<6; j++)
printf("T[%d][%d] = %d \t", i,j,T[i][j]) ;
}
}

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021


Page - 7

III. Les structures


Une structure rassemble plusieurs champs (des variables) en un seul type. Déclarer une variable de
ce type revient à allouer de la place pour tous les champs déclarés.

• Contrairement aux tableaux, une structure est un assemblage de variables qui peuvent avoir
différents types (par exemple long,char,int et double à la fois)
• Ces variables sont appelés des champs

1. Syntaxe
struct nom_structure
{
type variable;
type variable;
……
};

Remarque : Le ; à la fermeture de la structure est obligatoire, autrement, le programme se plantera

Exemple : on définit une structure Point qui contient deux variables de type double.

struct Point
{
double abscisse;
double ordonnee;
} ;
La structure sert de modèle. Pour déclarer une structure de type Point, on peut utiliser deux façons:
Première méthode :

struct Point
{
double abscisse;
double ordonnee;
} ;
struct Point premier, second ;

 Ici, on définit une structure Point. Après, on déclare deux structures appelées premier, second de
type Point dans la suite, ou bien dans une autre partie du code.
Deuxième méthode :

struct Point
{
double abscisse;
double ordonnee;
} premier, second ;

 Ici, on définit une structure Point, et on déclare deux structures appelées premier, second de
type Point. Les deux instructions sont faites ensemble.

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021


Page - 8

2. Accès aux membres de structures


L’accès à un membre d’une structure se réalise à l’aide de la variable de type structure et de
l’opérateur « . » suivi du nom du champ visé.

variable.membre

Exemple :

premier.abscisse = 45;
second.ordonnee = 30;
printf("abs = %d", second.abs);

3. Initialisation

L’initialisation d’une variable de type structure peut s’effectuer lors de la déclaration:

Exemple:
struct point {
int abs;
int ord;
} premier;

int main(void) {
struct point p1 = {0,0};
// equivalent à p1.abs = 0 et p1.ord = 0
printf(”%d %d \n”, p1.abs, p1.ord);
return (EXIT_SUCCESS);
}

Exemple: définition, déclaration, initialisation en même temps.


int main(void)
{
struct temps {
unsigned heures;
unsigned minutes;
double secondes;
} t1 = { 1, 45, 30.560 };
printf("heure = %d", t1.heures);
return 0;
}

On peut affecter une structure à une structure (ça revient à faire une copie de tous les champs).

Exemple :
struct to{
char a;
int b;
char c;
char d;
};
struct to z={'a',145,'y','u'};
struct to tt=z;
printf("%c %d %c %c\n",tt.a,tt.b,tt.c,tt.d);// ça donne: a 145 y u

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021


Page - 9

4. Les structures plus complexes


a) Les structures imbriquées
Un champ d’une structure peut être une structure.

Exemple :

int main(void) {
struct point {
int x;
int y;
};

struct rectangle{
struct point hautgauche;
struct point basdroit;
};

struct point d = {50,60};


struct point g = {40,50};

struct rectangle boite = {g,d};


int largeur = boite.basdroit.x – boite.hautgauche.x ;
int longueur = boite.basdroit.y – boite.hautgauche.y ;

int aire = largeur * longueur ;


printf("l’aire du rectangle est d \n", aire) ;
return (EXIT_SUCCESS);
}
 Le programme affiche 100.

b) Les tableaux membres des structures


Une structure peut avoir un ou plusieurs champs de type tableau. Ces tableaux peuvent contenir
tous les types de données en C.

Exemple

struct data{
int x[4] ;
char y[10] ;
} ;
 Pour accéder aux éléments du tableau qui sont membres d’une structure:
struct data record ;
record.x[0];
record.y[1];

c) Tableaux de structures
On peut avoir besoin de construire un tableau de structures.

Exemple: annuaire téléphonique contenant des informations (nom, prénom, numéro de téléphone)
pour chaque abonné.

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021


Page - 10

struct abonne{
char nom[10] ;
char prenom[10] ;
int tel ;
} ;

int main(void) {
int i ;
struct abonne annuaire[4] ;
/*remplissage de l’annuaire*/
for (i = 0; i< 4; i++){
printf("Donnez le nom ");
scanf("%s", annuaire[i].nom);
printf("Donnez le prenom ");
scanf("%s", annuaire[i].prenom);
printf("Donnez le numero de telephone ");
scanf("%d", &annuaire[i].tel);
}
return (EXIT_SUCCESS);
}

IV. Les énumérations


1. Définition des types énumérés
 Un type énuméré est un type dont on énumère, c’est-à-dire dont on donne la liste effective
de éléments de ce type. On voit immédiatement des cas où cela peut être intéressant, par
exemple pour traiter :

– les mois de l’année (janvier, février...) ;

– les noms de cartes à jouer (as, roi, dame...) ;

– les indications d’état civil (célibataire, marié, divorcé...).

 enum nom {id0, id1, ..., idn};

Une énumération ne prend donc qu'une case en mémoire et cette case peut prendre une des valeurs
qu’on lui affecte (et une seule à la fois).

- id0, id1, etc sont considérées comme des constantes énumérées entières.

Déclaration d’un type:

enum gender {male,female};

enum etatCivil {marie, celibataire, divorce, veuf};

enum jour {lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche} ;

Déclaration d’une variable d’un type énuméré:

enum jour j ; //la variable j est de type énumération, elle vaut lundi, ou
mardi, ou mercredi, etc

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021


Page - 11

Utilisation simple d’une variable d’un type énuméré:

Par exemple :

enum jour {lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche} ;


enum jour j ;
j = dimanche ;
if (j == lundi)
printf("Monday");
j = X; //erreur (X undeclared (first use in this function))

Remarque :

Un identificateur n’est pas une constante.

 enum impair {1, 3, 5, 7, 9} ; // erreur


 enum voyelles {’a’, ’e’, ’i’, ’o’, ’u’, ’y’} ; // erreur
 enum gender {"male","female"}; //erreur

2. Conversion des types énumérés


Le langage C considère les valeurs des types énumérés comme des constantes entières de type int,
commençant par 0.

j = dimanche;
printf("j = %d ", j);  affiche j = 6

On peut aussi faire: j = 6 ;

Remarque :

On peut forcer un élément d’un type à prendre une valeur donnée (grâce au signe = suivi d’une
constante entière), les éléments suivants étant alors incrémentés à partir de cette valeur.

Par exemple si on déclare :

enum jour {lundi,mardi,mercredi = 20,jeudi,vendredi,samedi,dimanche} ;

 lundi vaut 0, mardi vaut 1, mercredi vaut 20, jeudi la valeur 21, vendredi vaut 22, samedi
vaut 23, dimanche vaut 24.

enum volume {FAIBLE=10, MOYEN=50, FORT=100} ;

 Cette conversion donne plus d’informations dans cet exemple : FAIBLE correspond à 10% du
volume, MOYEN correspond à 50%, FORT correspond à 100%.

V. Les unions
Une union est, à l’image d’une structure, un regroupement d’objet de types différents.

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021


Page - 12

Une union ne peut contenir qu’un seul de ses membres à la fois. Autrement dit, une union peut
accueillir la valeur de n’importe lequel de ses membres, mais un seul à la fois.

 Un unique espace mémoire est partagé par les champs


 La taille d’une union correspond à la taille de son plus grand champ

Concernant la définition, elle est identique à celle d’une structure.

union toto {
type1 nom1;
type2 nom2;
...
typeN nomN;
};
union toto t ;

Exemple :

union Data {
int i;
float f;
char str[20];
};

union Data data;


data.i = 10;
data.f = 220.5;
strcpy( data.str, "C Programming");
printf( "data.i : %d\n", data.i); // 1917853763
printf( "data.f : %f\n", data.f); //
4122360580327794860452759994368.000000
printf( "data.str : %s\n", data.str); // C Programming

La dernière valeur affectée à l’union (« C Programming ») a occupé l’espace mémoire.

 Les unions sont utiles quand on doit manipuler des informations exclusives les unes des
autres
 Elles peuvent être utilisées de manière anonyme dans une structure

struct student {
char name[256];
union {
char login[16];
int id;
};
};
 En mettant le login et le id en union, on gagne de l’espace mémoire par rapport au cas où
login et id sont des champs de la structure student.

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021


Page - 13

VI. Définition de type


On peut donner un nom à un type donné, aussi compliqué soit-il, et utiliser ce nom au lieu de la
description complète du type à chaque fois que nous voudrons déclarer une variable ou un argument
de fonction.

 En C, on utilise le mot clé typedef

1. Cas des types simples


typedef type nom1, nom2 ;

nom1 i ; nom2 j ;

Exemple :

typedef unsigned int entier ; //entier devient un type équivalent à


unsigned int

entier i; // i est de type entier

2. Cas des types tableau


Exemple :

On définira par exemple un type ligne qui est une chaîne de 80 caractères de la façon suivante:
typedef char ligne [80]; // ligne devient un nom de type : tableau
de 80 char au maximum

Maintenant, on peut écrire :

ligne L1, L2 ;

3. Cas des types énumérés


Pour le type enum il faut utiliser le mot clé enum lors de la définition et aussi lors des déclarations
des variables de ces types. Pour éviter ceci, on peut renommer un tel type.

Exemple :

enum jour {dimanche, lundi, mardi, mercredi, jeudi, vendredi, samedi};


typedef enum jour day ;

ou bien :
typedef enum jour {dimanche, lundi, mardi, mercredi, jeudi, vendredi,
samedi} day;

maintenant day est un type, on peut directement écrire :


day d ; au lieu d’écrire enum jour day ;

4. Cas des structures


Exemple

struct array {
int t[50];
int size;
© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021
Page - 14

};
typedef struct array AA;
int main(void) {
AA a; //utilisation du nouveau nom
struct array b=a; //sans utilisation du nouveau nom
return(EXIT_SUCCESS);
}

© Ichrak Amdouni Programmation Procédurale et Langage C Eniso 2020-2021

Vous aimerez peut-être aussi