PRÉSENTATION

• On a précédemment étudié les tableaux, qui sont des types permettant de regrouper sous un
même identificateur plusieurs données de même type.
• Un type tableau est un type complexe homogène. Par comparaison, une structure est un type
complexe hétérogène :

Type complexe hétérogène : type de données décrivant une information

composite, constituée de plusieurs valeurs qui peuvent être elles-mêmes de
types différents (qui peuvent être eux-mêmes simples ou complexes).
PRÉSENTATION
• Autrement dit, une structure permet de regrouper sous un même identificateur plusieurs
données qui peuvent être complètement différentes. Ces données sont appelées les champs de
la structure.
Champ de structure : élément constituant la structure, caractérisé par un
identificateur et un type.

• Si on considère une structure comme un groupe de variables, alors un champ peut être comparé
à une variable. En effet, comme une variable, un champ possède un type, un identificateur, une
valeur et une adresse. Cependant, à la différence d’une variable, un champ n’est pas
indépendant, car il appartient à un groupe de champs qui forme sa structure.
DÉCLARATION
• La déclaration d’une structure se fait grâce au mot-clé struct, et en précisant :
• Son nom ;
• La liste de ses champs, avec pour chacun son nom et son type.

• exemple : on veut représenter des personnes par leurs noms, prénoms et âge.
DÉCLARATION
• On crée une structure appelée personne, contenant une chaîne de caractères nom pour représenter
le nom de famille, une autre prenom pour le prénom, et un entier age pour l’âge.
• Notez bien les points-virgules qui terminent la déclaration de chaque champ, et le point-virgule final
qui conclut la déclaration de la structure.
• La déclaration d’une variable structure se fait de façon classique, i.e. en précisant son type puis son
identificateur :

• On déclare une variable appelée x et dont le type est la structure personne définie précédemment.
DÉCLARATION
• Il n’est pas obligatoire de donner un nom à la structure : on parle alors de structure anonyme.
Structure anonyme : structure à laquelle on n’a pas associé d’identificateur.

• Exemple : on peut déclarer la structure précédente de la façon suivante :

DÉCLARATION
• Il n’est pas obligatoire de donner un nom à la structure : on parle alors de structure anonyme.
Structure anonyme : structure à laquelle on n’a pas associé d’identificateur.

• Exemple : on peut déclarer la structure précédente de la façon suivante :

Mais puisque cette structure n’a pas de nom, on ne peut pas y

faire référence par la suite, par exemple pour déclarer une
variable.
DÉCLARATION
• Quelques autres exemples de
structures :
• Représentation d’une date :
• Utilisation d’une structure dans une
autre structure :
• Représentation d’une matrice avec ses
dimensions :
 MÉMOIRE
• En mémoire, les structures
présentent également des
similitudes avec les tableaux. Les
champs qui composent une
structure sont en effet placés de
La différence avec les tableaux est qu’ici, les éléments sont hétérogènes,
dans le sens où ils peuvent avoir des types différents. Donc, l’espace façon contigüe en mémoire,
occupé par chaque élément (champ) n’est pas forcément le même. Dans exactement comme les éléments
l’exemple ci-dessus, le nom et le prénom occupent ainsi chacun 10 octets formant un tableau.
car il s’agit de tableaux de 10 caractères, mais l’âge n’en occupe que 2,
car c’est un entier short.
• Exemple : pour la structure de
l’exemple précédent, on a :
MANIPULATION
• Comme pour les tableaux, l’accès au contenu d’une variable structure se fait un élément à la
fois. En l’occurrence, cela se fait donc champ par champ. Cependant, alors que pour les tableaux
on utilise l’opérateur [] et l’index d’un élément, en revanche pour les structures on utilise
l’opérateur . (un simple point) et le nom du champ. La syntaxe est la suivante :

• Cette expression se manipule comme une variable classique.

• Exemple : modifier l’âge d’une personne x :
• Au niveau des types : l’expression prend le type du champ concerné. Donc ici, la variable x est de
type struct personne, mais x.age est de type short.
MANIPULATION
• L’initialisation d’une structure peut être effectuée à la déclaration, comme pour les tableaux :

• Les valeurs des champs doivent être indiquées dans l’ordre de leur déclaration dans le type
structure. Bien sûr, les types doivent correspondre.
TABLEAUX
• On a déjà vu qu’un tableau pouvait être défini sur n’importe quel type, qu’il soit simple ou complexe.
Par conséquent, il est possible de manipuler des tableaux de structures. La déclaration se fait comme
pour un tableau classique, à l’exception du fait qu’on précise un type structure.
• exemple : on déclare un tableau pouvant contenir 10 valeurs de type struct personne :

• Pour accéder à l’élément 𝑘 du tableau on utilise l’expression tab[k], dont le type est struct personne.
• Pour accéder au champ age de l’élément 𝑘 du tableau, on utilise l’expression tab[k].age, qui est de
type short. Pour accéder à la première lettre du champ prenom de l’élément 𝑘 du tableau, on utilise
l’expression tab[k].prenom[0], qui est de type char.
TABLEAUX
• exemple : considérons la structure suivante :
• Et déclarons le tableau tab suivant, contenant 7 valeurs de ce type :
• Alors la représentation de la mémoire est la suivante :
PARAMÈTRES

• Une variable de type structure peut bien entendu être utilisée comme paramètre d’une
fonction. Le passage se déroule alors comme pour une variable de type simple : on doit choisir
entre un passage par valeur ou par adresse.
• Remarque : il est important de bien remarquer que sur ce point, la structure diffère du tableau,
puisque le tableau est automatiquement passé par adresse.
PARAMÈTRES
• Supposons qu’on a une fonction recevant en paramètre l’adresse d’une variable de type struct
personne :

• Alors la modification d’un de ses champs passe par l’utilisation de l’opérateur *, comme on l’a déjà vu.
Par exemple, si on veut changer l’âge de la personne x, on utilisera l’expression :

• Notez bien l’utilisation des parenthèses. En effet, on veut appliquer l’opérateur * seulement à
l’expression x, qui est de type struct personne*. On obtient alors l’expression *x, qui est de type struct
personne. On peut alors appliquer l’opérateur. à cette expression *x, afin d’obtenir son champ age.
PARAMÈTRES
• Cependant, un opérateur spécial peut être utilisé pour accéder à un champ à partir de l’adresse
d’une structure. Il s’agit de l’opérateur ->, qu’on utilise de la façon suivante :

• Remarquez l’absence de parenthèses et de *. L’opérateur -> s’applique à l’adresse d’une

structure, ici x qui est de type struct personne*, et à un champ de la structure indiqué par cette
adresse, ici age qui est de type short. L’expression obtenue a pour valeur et pour type ceux du
champ concerné (ici, short).
• Remarque : les deux formes (*variable).champ et variable->champ sont équivalentes.