CHAPITRE 7

LES STRUCTURES

Mme TEMIMI.O
Année Universitaire: 2023/2024
 I – Définition
Le type structure permet de regrouper plusieurs données (variables
qui peuvent être de types différents) au sein d'une seule variable,
appelée structure.
Chaque élément de la structure est appelé champ ou membre.

Exemples:
✓Nombre_complexe : composé de 2 variables , pR (float), pIm (float)
✓Date : composée de 3 variables , jour (int), mois (int), année (int)
✓Personne : composée d’un nom (chaîne de caractères), un prénom
(chaîne de caractères) , num carte d’identité (int)et une date
naissance (Date).

1ère Génie Info A&B 2

II – Déclaration
1ère méthode:
On définit une structure à l’aide du mot réservé struct suivi par le nom
de la structure puis la liste des variables qu’elle doit contenir (type et
identificateur de chaque variable). Cette liste est délimitée par des
accolades.
Chaque variable contenue dans la structure est appelée champ ( ou
membre de la structure).
Syntaxe:
struct nom_structure {
Type_champ1 nom_champ1 ;
Type_champ2 nom_champ2 ;
Type_champ3 nom_champ3 ;
…
};
1ère Génie Info A&B 3
II – Déclaration
Exemple:
struct personne
{
char nom[20];
char prenom[20];
int cin;
};
Déclare l'identificateur personne comme étant le nom d'un type de
structure, composée de trois membres. On peut ensuite utiliser ce type
structure pour déclarer des variables, de la manière suivante :
struct personne p1,p2; /* qui déclare deux variables de type struct
personne nommées p1 et p2 */
p1
nom prénom cin

Champs de la variable p1
1ère Génie Info A&B 4
II – Déclaration
2ème méthode (avec « typedef »):
Permet d'indiquer au compilateur qu'il doit considérer notre structure
comme un type (comme int, float, etc.). Cette méthode permet de s’en
passer du mot clé struct à chaque fois que la structure est utilisée.
Syntaxe:
typedef struct {
Type_champ1 nom_champ1 ;
Type_champ2 nom_champ2 ;
Type_champ3 nom_champ3 ;
…
} nom_structure ;

1ère Génie Info A&B 5

II – Déclaration
2ème méthode (avec « typedef »):
Exemple:
#include<stdio.h>
typedef struct {
int jour ;
int mois ;
int annee ;
} Date;

typedef struct{
char nom [20];
char prénom[20];
int cin;
Date d;
} Etudiant;

1ère Génie Info A&B 6

II – Déclaration
II.1. Déclaration de variables structurées:
Si la structure est déclarée sans « typedef » :
Syntaxe:

struct nom_structure nom_variable ;

Exemple :
struct personne
{
char nom[20];
char prenom[20];
int cin;
};
struct Personne P1,P2,P3;
1ère Génie Info A&B 7
II – Déclaration
II.1. Déclaration de variables structurées:
Si la structure est déclarée sans « typedef » :
On peut combiner dans la même instruction la déclaration du type de
structure et des variables structurées
struct personne
{
char nom[20];
char prenom[20];
int cin;
} p1,p2;
Déclarer deux variables p1 et p2 et donne le nom personne à la structure.
La aussi, on pourra utiliser ultérieurement le nom struct personne pour
1ère Génie Info A&B 8
déclarer d'autres variables
II – Déclaration
II.1. Déclaration de variables structurées:
Si la structure est déclarée avec « typedef » :
Syntaxe:

nom_structure nom_variable ;
Exemple :
typedef struct {
int jour ;
int mois ;
int annee ;
} Date;

Date date_naissance, date_examen;

1ère Génie Info A&B 9
III- Utilisation d'une structure
On peut utiliser une structure de 2 manières différentes :
➢ En travaillant individuellement sur chacun des champs.
➢ En travaillant de manière globale sur l'ensemble de la structure.
III.1. Affectation :

Il est possible d'affecter une structure lors de sa

déclaration(initialisation).
Exemple 1:
Date date_naissance = {26,10,1990};
Contrairement aux tableaux, il est possible d'utiliser l'opérateur = pour
affecter une structure à partir d'une autre.
Exemple 2:
Date date_naissance = {26,10,1990};
Date birthday;
birthday = date_naissance;

1ère Génie Info A&B 10

III - Utilisation d'une structure
III.2. Comparaison entre variables structurées:
La comparaison directe de deux variables structurées de type Etudiant par
exemple:
Etudiant Etud1 , Etud2;
…. n'est pas
if (Etud1 == Etud2 ) printf("C'est pareil") ; permise.

La comparaison doit se faire champs par champs

III.3.utilisation des champs d'une structure

Il est possible d'avoir accès à un champ d'une variable structurée de

manière individuelle en utilisant l'opérateur "." Cet accès aux champs se
fait en utilisant le nom de la variable structurée suivi de l'opérateur "." et
du nom du champ désiré :

nom_variable_structurée.nom_champ
1ère Génie Info A&B 11
III - Utilisation d'une structure
III.3.utilisation des champs d'une structure

Chaque champ d'une structure peut être manipulé comme

n'importe quelle variable du type correspondant.
Exemple :
birthday.jour = 15; // affecte la valeur 15 au champ jour de la
variable structurée birthday.
printf("%s", E1.nom); // affiche le champ nom ( de type chaine)de
la variable E1.

E1 est une variable structurée

de type Etudiant

1ère Génie Info A&B 12

VI– Initialisation d'une structure

On retrouve pour les structures les règles d'initialisation qui sont en

vigueur pour tous les types de variables, à savoir :

➢Initialisation possible lors de sa déclaration mais on ne peut utiliser que

des constantes ou des expressions constantes.
struct personne pers = {"dupont","jean",0231747576};

➢Initialisation des champs par utilisation des fonctions scanf, getchar, gets.
scanf("%d", &E1.d.jour); // saisit le jour correspondant à une date de la
//variable structurée E1 de type Etudiant

1ère Génie Info A&B 13

V. Structure et fonction
La norme ANSI a introduit la possibilité de transmettre une structure en
argument d'une fonction, elle même pouvant retourner un tel objet (ne
pas passer les champs un à un).
Exemple : le programme suivant utilise une fonction qui renvoie un
complexe, somme de deux variables structurées " C1" et " C2 ". Le résultat
est "récupéré" dans une variable structurée " C ".
#include<stdio.h>
struct complexe
Paramètre passé par valeur
{
float reel,imag;
};
struct complexe Somme (struct complexe C1, struct complexe C2)
{
Variable locale qui sera la
struct complexe C;
valeur de retour de la
C.reel=C1.reel+ C2.reel;
fonction
C.imag=C1.imag+C2.imag;
return C;
}
1ère Génie Info A&B 14
V. Structure et fonction
int main()
{
struct complexe y1 = {2,3}, y2={ -4, 7}, y; // déclaration de 2 variables
structurées
y = Somme(y1,y2); // appel à la fonction : passage de y1 et y2 à la
// fonction →résultat dans y
printf("Partie réelle = %lf Partie imaginaire = %lf\n",y.reel,
y.imag);
}

={1ère Génie Info A&B 15

VI. Pointeur de structure
Dans le cas où l'on souhaite modifier le champ d'une variable structurée
déclarée dans le programme principal par l'intermédiaire d'une fonction,
il est nécessaire de transmettre à la fonction l'adresse de la variable
structurée que l'on récupère par un pointeur de même type.
La déclaration

struct complexe *
définit un pointeur qui pointera un espace mémoire contenant un objet de
type struct complexe.
Pour accéder aux champs d’une structure à partir d’un pointeur associé à
une variable structurée, on écrit:
(*nom_de_variable). nom_du_champ
Ou bien
nom_de_variable ->nom_du_champ.
1ère Génie Info A&B 16
VI. Pointeur de structure
Exemple:

Reprenons la fonction Somme mais avec le type void comme type de resultat:

void Somme(struct complexe C1, struct complexe C2, struct complexe *C)
{

(*C).reel=C1.reel+C2.reel;
Paramètre passé par
// C->reel=C1.reel+C2.reel; adresse

(*C).imag=C1.imag+C2.imag;

//C->imag=C1.imag+C2.imag;

1ère Génie Info A&B 17

 VII – Tableau de structures
On peut définir un tableau de structures
Déclaration:

nom structure nom_tableau[taille];

Exemple:

Etudiant TE[10]; // déclaration d’un tableau de 10 éléments de type

Etudiant
Utilisation:
strcpy(TE[i].nom,"DUPONT") /* pour un indice i quelconque
*/
strcpy(TE[i].prenom,"JEAN");
scanf(" %d ",&TE[i].cin);
1ère Génie Info A&B 18
VII – Tableau de structures
Pour calculer le nombre des étudiants nés après l’année 1990, on écrit la
fonction suivante:
int nb_etud( Etudiant TE[], int n)
{
int i,nb=0;
for(i=0;i<n;i++)
if(TE[i].d.annee>=1990)
nb++;
return nb;
}

1ère Génie Info A&B 19

 Application
Soit la structure suivante :
typedef struct { int dim ; /*nombre d’éléments du vecteur */
int tab[50] ; /*tableau contenant ces éléments
*/
} vecteur;
On demande d’écrire un programme qui renverse le contenu d’un
vecteur, pour cela développez les fonctions suivantes :
1. La fonction Lecture( ) qui permet de lire un vecteur
(dimension et contenu).
2. La fonction Renverse( ) qui, étant donné un vecteur, renverse
son contenu ( le 1er élément devient le dernier, le 2ème devient
l’avant dernier,….)
3. La fonction affiche( ) qui affiche les éléments d’un vecteur.
4. main( ) qui appelle les fonctions précédentes et affiche le
vecteur avant et après appel de la fonction Renverse.
1ère Génie Info A&B 20
Solution
#include<stdio.h>
#include<conio.h>
typedef struct
{
int dim;
int tab[100];
}vecteur;
void lire(vecteur *v)
{ int i;
do{
printf("\n donner la dimension du tableau");
scanf("%d",&v->dim);
}while(v->dim<2);
for(int i=0;i<v->dim;i++)
{
printf("\ntabreel[%d]=",i);
scanf("%d", &v->tab[i]); // ou bien scanf("%d", v->tab+i);
} 1ère Génie Info A&B 21
 Solution
void inverser(vecteur *v)
{
int i,aux;
for(i=0;i<v->dim/2;i++)
{
aux=v->tab[i];
v->tab[i]=v->tab[v->dim-i-1];
v->tab[v->dim-i-1]=aux;
}
}
void affiche(vecteur v)
{ int i;
printf("\n Dimension : %d\n", v.dim);
printf("\n Contenu tableau : ");
for(i=0;i<v.dim;i++)
printf("%d\t",v.tab[i]);
}

1ère Génie Info A&B 22

 Solution
int main()
{
vecteur v;
lire(&v);
printf("\n**********************************************");
printf("\n AFFICHAGE VECTEUR AVANT PERMUTATION:\n");
printf("\n**********************************************");
affiche(v);
inverser(&v);
printf("\n**********************************************");
printf("\n AFFICHAGE VECTEUR APRES PERMUTATION:\n");
printf("\n**********************************************");
affiche(v);
getch();
}

1ère Génie Info A&B 23