2-1-Cours - Structures de Donnéess

1ère année/ Semestre S2 Pr.
HALKHAMS IMANE
Les structures de données

Notion de structure
Il est habituel en programmation d'avoir besoin d'un mécanisme permettant de grouper un certain
nombre de variables de types différents au sein d'une même entité. On travaille par exemple sur un
fichier de personnes et on voudrait regrouper une variable de type chaîne de caractères pour le nom,
une variable de type entier pour le numéro d'employé, etc. La réponse à ce besoin est le concept
d'enregistrement : un enregistrement est un ensemble d'éléments de types différents repérés par un
nom. Les éléments d'un enregistrement sont appelés des champs.
Déclaration de structure
Il y a plusieurs méthodes possibles pour déclarer des structures.
1-Première méthode
La déclaration :
struct personne
{
char nom[20];
char prenom[20];
int num_employe;
}; (remarque : il est obligatoire de mettre un point-virgule après l'accolade fermante).
Déclare l'identificateur « personne » comme étant le nom d'un type de structure composée
de trois éléments, dont le premier est un tableau de 20 caractères nommé « nom », le
second un tableau de 20 caractères nommé « prenom », et le dernier un entier nommé
« num_employe ». Dans le jargon du langage C, l'identificateur « personne » est une
étiquette de structure. 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 de noms p1 et p2;
2-Deuxième méthode
On peut déclarer des variables de type structure sans utiliser d'étiquette de structure, par
exemple :
struct
{
char nom[20];
char prenom[20];
int num_employe;
} p1,p2;
Déclare 2 variables de noms p1 et p2 comme étant deux structures de trois éléments, mais
ne donne pas de nom au type de la structure. L'inconvénient de cette méthode est qu'il est
impossible de déclarer une autre variable du même type par la suite. En effet, si on écrit :
struct
{
char nom[20];
char prenom[20];
int num_employe;
} p3;
Les deux structures ont beau avoir le même nombre de champs, avec les mêmes noms et les
mêmes types, elles seront considérées de types différents. Il sera impossible en particulier
d'écrire p3 = p1.
3-Troisième méthode
On peut combiner déclaration d'étiquette de structure et déclaration de variables, comme :
struct personne
{
char nom[20];
char prenom[20];
int num_employe;
} p1,p2;
Déclare les deux variables p1 et p2 et donne le nom personne à la structure. Là aussi, on pourra
utiliser ultérieurement le nom struct personne pour déclarer d'autres variables :
struct personne pers1, pers2, pers3;
qui seront du même type que p1 et p2. De ces 3 méthodes c'est la première qui permet de
bien séparer la définition du type structure de ses utilisations.
Initialisation d'une structure
Une structure peut être initialisée par une liste d'expressions constantes à la manière des
initialisations de tableau. Exemple :
struct personne p = {"Jean", "Dupond", 7845};
Opérateurs sur les structures :
Accès aux membres des structures
Pour désigner un membre d'une structure, il faut utiliser l'opérateur de sélection de membre
qui se note . (point). Par exemple, si p1 et p2 sont deux variables de type struct personne, on
désignera le membre nom de p1 par p1.nom et on désignera le membre num_employe de
p2 par p2.no_employe. Les membres ainsi désignés se comportent comme n'importe quelle
variable et par exemple, pour accéder au premier caractère du nom de p2, on écrira :
p2.nom[0].
Affectation de structures
On peut affecter une structure à une variable structure de même type, grâce à l'opérateur
d'affectation :
struct personne p1,p2

...
p1 = p2;
Comparaison de structures
Aucune comparaison n'est possible sur les structures, même pas les opérateurs == et !=.
Tableaux de structures
Une déclaration de tableau de structures se fait selon le même modèle que la déclaration
d'un tableau dont les éléments sont de type simple. Supposons que l'on ait déjà déclaré la
struct personne, si on veut déclarer un tableau de 100 structures de ce type, on écrira :
struct personne t[100];

Pour référencer le nom de la personne qui a l'index i dans t, on écrira : t[i].nom.
Pointeurs vers une structure

Supposons que l'on ait défini la struct personne à l'aide de la déclaration :
struct personne
{
...
};
on déclarera une variable de type pointeur vers une telle structure de la manière suivante :
struct personne *p;

On pourra alors affecter à p des adresses de struct personne. Exemple :
struct personne
{
...
};
int main()
{
struct personne pers; /* pers est une variable de type struct personne */
struct personne *p; /* p est un pointeur vers une struct personne */
p = &pers;
}
Utilisation d’une structure de données :
Maintenant que la structure est définie, elle devra être enregistrée dans un fichier de type
« .h ». On va pouvoir l'utiliser dans une fonction du programme .c de la manière suivante :
#include "structure.h" // Inclusion du .h qui contient les prototypes et structures

int main()
{ struct personne p1; // Création d'une variable "p1" de type personne
return 0;
}
Cette variable est automatiquement composée de trois sous-variables : nom[20]; prenom[20];
num_employe.
Le typedef :
Dans le fichier .h qui contient la définition de notre structure de type personne. Nous allons
ajouter une instruction appelée « typedef » qui sert à créer un alias de structure, équivalent
à celle-ci. Pour ce, il faut commencer par typedef juste avant la définition de la structure :
typedef struct personne personne;
struct personne
{ char nom[20]; char prenom[20]; int num_employe; };
En clair, cette ligne dit « Écrire le mot personne est désormais équivalent à écrire struct
personne. En faisant cela, on aura plus besoin de mettre le mot struct à chaque définition de
variable de type personne. On peut donc retourner dans notre main et écrire tout
simplement :
int main()
{personne p1; // L'ordinateur comprend qu'il s'agit de "struct personne"
return 0;}
Exemple : programme qui enregistre une personne avec son nom, age et ville :
1-Fichier.h
struct personne
{ char nom[10];
int age;
char ville[10]; };
2-Fichier.c
#include<stdio.h>
#include "structure_personne.h"
int main()
{ struct personne p1;
printf("veuillez saisir votre nom");
scanf("%s",p1.nom);
printf("veuillez saisir votre age");
scanf("%d",&p1.age);
printf("veuillez saisir votre ville");
scanf("%s",p1.ville);
printf("votre nom est %s, votre age est %d et votre ville est %s
",p1.nom,p1.age,p1.ville); }

2-1-Cours - Structures de Donnéess

Transféré par

Droits d'auteur :

Formats disponibles

2-1-Cours - Structures de Donnéess

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

2-1-Cours - Structures de Donnéess

Transféré par

Droits d'auteur :

Formats disponibles

1ère année/ Semestre S2 Pr.

Les structures de données

qui déclare deux variables de type struct personne de noms p1 et p2;

struct personne pers1, pers2, pers3;

Initialisation d'une structure

struct personne p = {"Jean", "Dupond", 7845};

Opérateurs sur les structures :

Accès aux membres des structures

struct personne p1,p2

struct personne t[100];

Pointeurs vers une structure

struct personne *p;

#include "structure.h" // Inclusion du .h qui contient les prototypes et structures

Vous aimerez peut-être aussi