Vous êtes sur la page 1sur 36

Les structures en C

Pr. Mohamed EL ANSARI

Département d’Informatique
Faculté des Sciences, Université Ibn Zohr
Agadir

melansari@gmail.com

Filière: SMI4
Module: Algorithmique & Structures de données

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 1 / 36


Introduction

Une structure est une collection d’une ou plusiseurs variables,


généralement, ayant des types différents.
Les variables d’une structure sont groupées sous un seul nom.
Les structures permettent d’organiser les données compliquées. Les
variables liées sont groupés en seule entité au lieu des entités séparées.
Exemple-1, un employé peut être décrit par:
Nom,
Prénom.
SOM.
Salaire.
Adresse.
....
Le nom peut être aussi décrit par une structure.
Exemple-2, un point est une paire de coordonnées, un rectangle est
une paire de points, ...etc.
Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 2 / 36
Dé finition d’une structure
Le langage C permet au programmeur de construire ses propres types
de données agrégées.
Pour cela, le programmeur doit préciser:
le nom donné au type;
la composition du type, c’est à dire le nom et la nature des données
qu’il contient.
La syntaxe de définition d’un type nomé nom structure est:
struct nom structure{
type1 var1;
type2 var2;
type3 var3;
...
};
Cette structure définit le type struct nom structure composée des
variables var1, var2, var3, ...
Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 3 / 36
Dé finition d’une structure

Exemple: un point d’un plan 2-D est caractérisé par ses coordonnées
x et y. Supposant que les coordonnées sont des entiers, la strucure
décrivant un point est déclarée en C par:

struct point{
int x;
int y;
};

Attention: le mot-clé struct fait partie intégrante du nom du type.


Le mot-clé struct introduit la déclaration de la structure, qui est une
liste de déclarations placées entre { et }.
Le mot-clé struct peut être suivi d’un nom qu’on souhaite attribuer
à la structure. Dans ce cas, point. Ce nom sera utilisé par la suite
pour se référer à la structure (déclaration des variables de ce type).

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 4 / 36


Dé finitions
Les variables nommées dans la structure sont appelées les membres
ou champs de la structure.
La déclaration d’une structure définit un nouveau type.
struct point{
int x;
int y;
};
struct point contitue le nouveau type.
Exemples de nouveaux types:

struct date{
struct complex{
int jour;
int real;
int mois;
int imaginary;
int annee;
};
};
Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 5 / 36
Dé clarations

Définition de la structure struct point (le nouveau type):

/*
struct point{
int x;
int y;
};

Déclaration d’une variable de type struct point:

/* une variable simple de la structure */


struct point p; /* une variable simple de la structure */
struct point q, r;

/* un tableau de 20 elements de la structure */


struct point t[20];

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 6 / 36


Différentes façons de déclarer les variables d’une structure.

p1, p2, p3, p4, p5 sont des


variables globales initialisées
struct point{ automatquement à 0.
int x;
p1, p2, p3 ont été déclarées
int y;
avec la définition de la
} p1, p2, p3 ;
structure.
struct point p4, p5; p4, p5, p6 déclarées en
utilisant le nom du nouveau
main(){ type.
struct point p6;
p6 est une variable locale
printf("%d %d\n",p1.x, p1.y);
initialisée aléatoirement.
printf("%d %d\n",p4.x, p4.y);
printf("%d %d\n",p6.x, p6.y);
La sortie
} 0 0
0 0
134513753 13897716
Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 7 / 36
Différentes façons de déclarer les variables d’une structure.

Le nom du nouveau type non


spécifié.
struct {
Chaque fois qu’on souhaite
int x;
déclarer une nouvelle variable
int y;
on a besoin de réécrire le code
} q1, q2;
de la structure.
main(){ q1 et q2 sont des variables
struct { globales initialisées
int x; automatquement à 0.
int y;
q3, q4 et q5 sont des
} q3, q4, q5;
variables locales initialisées
aléatoirement.
printf("%d %d\n",q1.x, q1.y);
printf("%d %d\n",q3.x, q3.y);
} La sortie
0 0
134513721 14196724
Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 8 / 36
Utilisation des structures

/* définition de la structure (nouveau type) */


struct point{
int x;
int y;
};

/* Programme principal */
int main(int argc, char *argv[])
{
struct point p;
struct point q, r;
struct point t[20];
return 0;
}

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 9 / 36


Initialisation, accès aux membres

Les membres peuvent être initialisées au moment de la déclaration de


la variable de type structure.
struct point pt1 = {20,30};
struct point pt2={2,3}, pt3={-7,50};
Les valeurs d’initialisation sont fournies entre { et }.
L’affectation des initialisations suit l’ordre d’apparition des champs
dans la structure. La Nième valeur est affectée au champ introduit à la
Nième position dans définition de la structure.
Exemple: dans struct point pt1 = {20,30}; x reçoit 20 et y
reçoit 30.

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 10 / 36


Initialisation, accè s aux membres

Accès aux champs s’effectue comme suit:


NomDeStructure.membre
Le point (.) permet de connecter le champ (variable membre) à la
structure dont il fait partie.
Modifier les valeurs des champs des structures:
pt1.x = -2; pt1.y = 0;
pt2.x = pt1.y; pt2.y = 2*pt1.x;

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 11 / 36


Initialisation, accè s aux membres

Différentes initialisations
#include<stdio.h>
struct point{
int x;
int y;
};
Sortie du programme
int main(int argc, char* argv[]) a = (2,3)
{ b = (2,0)
struct point a = {2,3}, b = {2}; c = (0,0)
struct point c = {}, d ; d = (134513833,8601588)
printf("a = (%d,%d)\n", a.x, a.y);
printf("b = (%d,%d)\n", b.x, b.y);
printf("c = (%d,%d)\n", c.x, c.y);
printf("d = (%d,%d)\n", d.x, d.y);
return 0;
}

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 12 / 36


Opérations sur les champs

Afficher les coordonnées du point pt1 :


printf("%d,%d",pt1.x, pt1.y);
Calcul de la distance du point pt1 de l’origine (0,0):
float dist;
dist = (float) sqrt((float)pt1.x*pt1.x +
(float)pt1.y*pt1.y);

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 13 / 36


Structures imbriquées

Une structure peut comporter parmi ses champs d’autres structures.


Exemple, un rectangle peut être représenté par deux points (coins
opposés diagonalement).
struct rect{
struct point pt1;
struct point pt2;
};
La structure rect contient deux structures de type point.
Déclaration d’une variable de type rect:
struct rect rectangle; /* sans initialisation*/
struct rect rectangle = {{1,2},{3,4}}; /* avec
initialisation*/
rectangle.pt1.x se réfère à la variable x membre du point pt1.

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 14 / 36


Structures imbriquées

Modification des données membres de la variable rectangle:


rectangle.pt1.x = -2; rectangle.pt1.y = 3; /* point pt1
*/
rectangle.pt2.x = -21; rectangle.pt2.y = 13; /* point
pt2 */
Autre exemple d’imbriquation: une donnée membre étant un tableau
à une dimension.
#define MAX 12
struct vecteur{
int taille;
int mat[MAX];
};

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 15 / 36


Structures imbriqué es

#include<stdio.h>
#define MAX 12
struct vect{
int taille;
float array[MAX];
};

int main(int argc, char* argv[])


{
struct vect a = {3, {1,2,3}};
struct vect b, c = {2, 3.6, .5f};
return 0;
}

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 16 / 36


Structures imbriqué es

#define MAX 20
struct id {
char firstname[MAX];
char lastname[MAX];
};
struct people { Pas d’ambigüité dans la
struct id id; ligne struct id id; de
la structure people:
int age;
id est une variable
};
membre
int main(int argc,char* argv[]){ le type de id est
struct people p; struct id
strcpy(p.id.firstname,"xxxx");
strcpy(p.id.lastname,"yyyy");
p.age=943;
return 0;
}
Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 17 / 36
Organisation des champs

Les chams sont organisés dans l’ordre de leurs déclarations dans la structure.

struct foo{
int a;
char b; Sortie
float c;
0xbfc98bb4
};
0xbfc98bb8
int main(int argc,char* argv[]){
0xbfc98bbc
struct foo f;
0xbfc98bb4
printf("%p\n",&(f.a));
printf("%p\n",&(f.b));
printf("%p\n",&(f.c)); L’adresse d’une structure
printf("%p\n",&f); = l’adresse de son premier
return 0; champ.
}

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 18 / 36


Alignement des champs

L’adresse d’une structure = l’adresse de son premier champ.


Pour les champs, le compilateur fait l’alignement pour avoir
des adresses multiples de la taille des données,
des adresses multiples de la taille des pointeurs,
...

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 19 / 36


Alignement des champs

La taille de la structure dépend de l’ordre de ses champs.

struct toto{ struct tata {


char a; int a;
int b; char b;
char c; char c;
char d; char d;
}; };
sizeof(struct toto) = 12 sizeof(struct tata) = 8

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 20 / 36


Alignement des champs

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 21 / 36


Choix des champs
On peut mettre n’importe quel type pour lequel la taille est connue
par le compilateur.
On ne peut pas mettre la structure elle-même
struct liste{
int valeur;
struct liste suivant;
};

Erreur de compilation:
le champ ‘‘suivant’’ a un type incomplet
On peut mettre comme membre un pointeur sur la structure
elle-même puisque la taille d’un pointeur est connue.
struct liste{
int valeur;
struct liste * suivant;
};Mohamed EL ANSARI (FS-Agadir)
Pr. Les structures en C 22 / 36
Structures et fonctions

Une structure peut être utilisée comme argument ou résultat d’une


fonction.
Trois possibilités pour le passage des structures aux functions:
Passer les champs (membres) séparement;
Passer la structure entière;
Passer un pointeur sur la structure.

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 23 / 36


une fonction qui prend deux entiers et retourne une
structure point

struct point makepoint(int x, int y)


{
struct point temp;
temp.x =x;
temp.y = y;
return temp;
}

Attention: il ne faut pas confondre la variable x fournie en argument avec celle


qui est membre de la structure temp (de même pour la variable y).

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 24 / 36


une fonction qui prend deux entiers et retourne une
structure point

struct point makepoint(int x, int y)


{
struct point temp;
temp.x =x;
temp.y = y;
return temp;
}
main(){
struct rect rectangle;
struct point middle;
rectangle.pt1 = makepoint(0,0);
rectangle.pt2 = makepoint(XMAX,YMAX);
middle = makepoint((rectangle.pt1.x+rectangle.pt2.x)/2,
(rectangle.pt1.y+rectangle.pt2.y)/2);
}

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 25 / 36


Les arguments et la valeur de retour sont des structures

Somme de deux points


/* ajouter deux points */
struct point addpoint(struct point p1, struct point p2)
{
p1.x += p2.x;
p1.y += p2.y;
return p1;
}
main(){
struct point a,b,c;
a = makepoint(2,3); b = makepoint(0,-1);
c = addpoint(a,b);
}

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 26 / 36


Les arguments sont des pointeurs sur des structures

Déclaration d’un pointeur sur une structure:


struct point *pp;
pp pointe sur la structure point, (*pp).x et (*pp).y sont les
membres.
Utilisation du pointeur pp:
struct point origin, *pp;
pp = &origin;
printf("origin is (%d,%d)\n",(*pp).x,(*pp).y);
Si p est un pointeur sur une structure, l’accès aux membre s’effectue
par : p->membre
printf(”origin est (%d,%d)\n”,pp→x,pp→y);

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 27 / 36


Les arguments sont des pointeurs sur des structures

Somme de deux points


/* ajouter deux points */
struct point addpoint(struct point *p1,
struct point *p2)
{
p1→x += p2→x;
p1→y += p2→y;
return *p1;
}
...
struct point a,b,c;
a = makepoint(2,3); b = makepoint(0,-1);
c = addpoint(&a,&b);

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 28 / 36


Structures et tableaux

Tableau de structures
struct key{
char *word;
int count;
} keytab[ ] = {
"auto",2,
"break",7,
"case",3 };

Accès aux i eme membres de la structure: keytab[i].word et


keytab[i].count, l’instruction printf(" keytab[1] = %s
%d\n",keytab[1].word,keytab[1].count) affiche keytab[1] =
break 7

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 29 / 36


Nouveaux types: typedef
Le langage C permet de créér de nouveaux types de données par
typedef. Par exemple la déclaration:
typedef int Length;

fait que Length constitue un synonyme de int.


Déclaration des variables du nouveau type (Length):
Length len, maxlen; /* variables simples */
Length * lengths[10]; /* tableau de 10 pointeurs */

Pointeur sur un caractère (chaı̂ne de caractères):


/* Definition du nouveau type */
typedef char * String;
/* declaration des variables du nouveau type */
String p, lineptr[10];
p = malloc(10);
Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 30 / 36
Nouveaux types: typedef

La structure point:
typedef struct point POINT;
...
POINT p1,p2; /* declaration de deux points */
POINT p3[10]; /* tableau de 10 points */
POINT *p4; /* pointeur sur un point */
p4 = malloc(10*sizeof(POINT)); /* allocation de l’espace
memoire pour 10 points */

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 31 / 36


Nouveaux types: typedef

Différentes façons de définir les nouveaux types:

struct point{
int x; Définition de la structure
int y; struct point .
}; typedef fait appel à
typedef struct point point; struct point pour créer le
nouveau type point.
main(){ Pas d’ambiguı̈té: le nouveau
point p, q = {3,-6}; type point peut prendre le
point * r; même nom que celui de la
point s[20]; structure (struct point).
}

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 32 / 36


Nouveaux types: typedef

Différentes façons de définir les nouveaux types:

typedef struct point{


int x;
int y; Une seule instruction pour
} point; définir la structure struct point
et le nouveau type point.
main(){ Définition de la structure
point p, q = {3,-6}; struct point à l’intérieur de
point * r; l’instruction typedef.
point s[20];
}

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 33 / 36


Nouveaux types: typedef

Différentes façons de définir les nouveaux types:

typedef struct{
int x;
int y;
} point; Aucun nom n’a été attribué à la
structure.
main(){ Le type struct point n’existe
point p, q = {3,-6}; pas.
point * r;
point s[20];
}

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 34 / 36


Exercice applicatif

On souhaite réaliser une liste des étudiants de la filière SMI4. Chaque


étudiant est caractérisé par:
Nom et prénom (deux chaı̂nes de caractères).
Date de naissance qui est elle aussi une structure représentée par 3
entiers (jour, mois, année).
CNE (entier).
Les modules auxquels l’étudiant est inscrit (structure comportant un
tableau de chaı̂nes de caractères pour les modules et un entier pour le
nombre de modules).
Donner la structure Etudiant correspondante.
Donner un programme en C permettant de :
1 lire le nombre NbreEtudiant d’étudiants inscrits en SMI4.
2 saisir la liste des NbreEtudiant étudiants (la liste est copiée dans un
tableau ListeEtudiant).
3 trier la liste par ordre alphabétique des noms.

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 35 / 36


Bibliographie

Brian W. Kernighan and Dennis M. Ritchie, ” The C programming


language”, Prentice Hall Inc.

Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 36 / 36