Les Structures

Les structures en C
Pr. Mohamed EL ANSARI
Département d’Informatique
Faculté des Sciences, Université Ibn Zohr
Agadir
melansari@gmail.com
Filière: SMI4-SM4
Module: Structures de données
https://sites.google.com/site/fsagadirsmi4/
Pr. Mohamed EL ANSARI (FS-Agadir) Les structures en C 1 / 36

Introduction
Introduction
Une structure est une collection d’une ou plusiseurs variables,
généralement, ayant des types différents.
Les variables d’une structure sont groupées sous un seul nom.
Les structures permettent d’organiser les données compliquées. Les
variables liées sont groupés en seule entité au lieu des entités séparées.
Exemple-1, un employé peut être décrit par:
Nom,
Prénom.
SOM.
Salaire.
Adresse.
....
Le nom peut être aussi décrit par une structure.
Exemple-2, un point est une paire de coordonnées, un rectangle est
une paire de points, ...etc.
Définition d’une structure

Le langage C permet au programmeur de construire ses propres types
de données agrégées.
Pour cela, le programmeur doit préciser:
le nom donné au type;
la composition du type, c’est à dire le nom et la nature des données
qu’il contient.
La syntaxe de définition d’un type nomé nom structure est:
struct nom structure{
type1 var1;
type2 var2;
type3 var3;
...
};
Cette structure définit le type struct nom structure composée des
variables var1, var2, var3, ...
Exemple: un point d’un plan 2-D est caractérisé par ses coordonnées
x et y. Supposant que les coordonnées sont des entiers, la strucure
décrivant un point est déclarée en C par:
struct point{
int x;
int y;
};
Attention: le mot-clé struct fait partie intégrante du nom du type.

Le mot-clé struct introduit la déclaration de la structure, qui est une
liste de déclarations placées entre { et }.
Le mot-clé struct peut être suivi d’un nom qu’on souhaite attribuer
à la structure. Dans ce cas, point. Ce nom sera utilisé par la suite
pour se référer à la structure (déclaration des variables de ce type).
Définitions
Les variables nommées dans la structure sont appelées les membres
ou champs de la structure.
La déclaration d’une structure dé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;
};
};
Déclarations
Définition de la structure struct point (le nouveau type):
/*
struct point{
int x;
int y;
};
Dé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];
Différentes façons de déclarer les variables d’une structure.
p1, p2, p3, p4, p5 sont des

variables globales initialisées
struct point{ automatquement à 0.
int x;
int y; p1, p2, p3 ont été déclarées
} p1, p2, p3 ; avec la définition de la
structure.
struct point p4, p5; p4, p5, p6 déclarées en
utilisant le nom du nouveau
main(){ type.
struct point p6;
printf("%d %d\n",p1.x, p1.y); p6 est une variable locale
printf("%d %d\n",p4.x, p4.y); initialisée aléatoirement.
printf("%d %d\n",p6.x, p6.y);
La sortie
} 0 0
0 0
134513753 13897716
Différentes façons de déclarer les variables d’une structure.
Le nom du nouveau type non

spécifié.
struct {
int x; Chaque fois qu’on souhaite
int y; déclarer une nouvelle variable
} q1, q2; on a besoin de réécrire le code
de la structure.
main(){ q1 et q2 sont des variables
struct { globales initialisées
int x; automatquement à 0.
int y;
} q3, q4, q5; q3, q4 et q5 sont des
variables locales initialisées
printf("%d %d\n",q1.x, q1.y); aléatoirement.
printf("%d %d\n",q3.x, q3.y);
} La sortie
0 0
134513721 14196724
Utilisation des structures
/* dé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;
}

Initialisation, accès aux membres
Les membres peuvent être initialisées au moment de la dé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 Nième valeur est affectée au champ introduit à la
Nième position dans définition de la structure.
Exemple: dans struct point pt1 = {20,30}; x reçoit 20 et y
reçoit 30.

Accès aux champs s’effectue comme suit:

NomDeStructure.membre
Le point (.) permet de connecter le champ (variable membre) à 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;

Diffé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;
}
Opérations sur les champs
Afficher les coordonné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);

Structures imbriquées
Une structure peut comporter parmi ses champs d’autres structures.

Exemple, un rectangle peut être représenté par deux points (coins
opposés diagonalement).
struct rect{
struct point pt1;
struct point pt2;
};
La structure rect contient deux structures de type point.
Dé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 réfère à la variable x membre du point pt1.

Modification des donné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 donnée membre étant un tableau
à une dimension.
#define MAX 12
struct vecteur{
int taille;
int mat[MAX];
};

#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;
}

#define MAX 20
struct id {
char firstname[MAX];
char lastname[MAX];
};
struct people { Pas d’ambigüité 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;
}
Organisation des champs
Les chams sont organisés dans l’ordre de leurs dé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.
}

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 données,
des adresses multiples de la taille des pointeurs,
...

La taille de la structure dé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


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-mê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-même
puisque la taille d’un pointeur est connue.
struct liste{
int valeur;
struct liste * suivant;
};
Structures et fonctions
Une structure peut être utilisée comme argument ou résultat d’une

fonction.
Trois possibilités pour le passage des structures aux functions:
Passer les champs (membres) séparement;
Passer la structure entière;
Passer un pointeur sur la structure.

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 même pour la variable y).

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);
}

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);
}

Les arguments sont des pointeurs sur des structures
Dé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’accès aux membre s’effectue
par : p->membre
printf(”origin est (%d,%d)\n”,pp→x,pp→y);

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);

Structures et tableaux
Structures et tableaux
Tableau de structures
struct key{
char *word;
int count;
} keytab[ ] = {
"auto",2,
"break",7,
"case",3 };
Accè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

typedef
Nouveaux types: typedef

Le langage C permet de créér de nouveaux types de données par
typedef. Par exemple la déclaration:
typedef int Length;
fait que Length constitue un synonyme de int.

Déclaration des variables du nouveau type (Length):
Length len, maxlen; /* variables simples */
Length * lengths[10]; /* tableau de 10 pointeurs */
Pointeur sur un caractère (chaı̂ne de caractères):

/* Definition du nouveau type */
typedef char * String;
/* declaration des variables du nouveau type */
String p, lineptr[10];
p = malloc(10);
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 */

typedef
Différentes façons de définir les nouveaux types:
struct point{
int x; Définition de la structure
int y; struct point .
}; typedef fait appel à
typedef struct point point; struct point pour créer le
nouveau type point.
main(){ Pas d’ambiguı̈té: le nouveau
point p, q = {3,-6}; type point peut prendre le
point * r; même nom que celui de la
point s[20]; structure (struct point).
}

typedef
typedef struct point{

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

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

typedef
Exercice applicatif
On souhaite réaliser une liste des étudiants de la filière SMI4. Chaque

étudiant est caractérisé par:
Nom et prénom (deux chaı̂nes de caractères).
Date de naissance qui est elle aussi une structure représentée par 3
entiers (jour, mois, année).
CNE (entier).
Les modules auxquels l’étudiant est inscrit (structure comportant un
tableau de chaı̂nes de caractè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’étudiants inscrits en SMI4.
2 saisir la liste des NbreEtudiant étudiants (la liste est copiée dans un
tableau ListeEtudiant).
3 trier la liste par ordre alphabétique des noms.

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

language”, Prentice Hall Inc.

Les Structures

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Les Structures

Transféré par

Droits d'auteur :

Formats disponibles

Les structures en C

Pr. Mohamed EL ANSARI

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

Définition d’une structure

Définition d’une structure

Attention: le mot-clé struct fait partie intégrante du nom du type.

Déclaration d’une variable de type struct point:

/* une variable simple de la structure */

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

Différentes façons de déclarer les variables d’une structure.

p1, p2, p3, p4, p5 sont des

Différentes façons de déclarer les variables d’une structure.

Le nom du nouveau type non

Utilisation des structures

/* définition de la structure (nouveau type) */

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

Initialisation, accès aux membres

Les membres peuvent être initialisées au moment de la déclaration de

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

Initialisation, accès aux membres

Accès aux champs s’effectue comme suit:

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

Initialisation, accès aux membres

Opérations sur les champs

Afficher les coordonnées du point pt1 :

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

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

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

Modification des données membres de la variable rectangle:

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

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

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

Organisation des champs

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.

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

Alignement des champs

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

struct toto{ struct tata {

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

Erreur de compilation: le champ ‘‘suivant’’ a un type incomplet

Une structure peut être utilisée comme argument ou résultat d’une

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

une fonction qui prend deux entiers et retourne une

struct point makepoint(int x, int y)

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

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

une fonction qui prend deux entiers et retourne une

struct point makepoint(int x, int y)

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

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

Les arguments sont des pointeurs sur des structures

Déclaration d’un pointeur sur une structure:

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

Les arguments sont des pointeurs sur des structures

Somme de deux points

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