Chapitre 5 : Structures et tableaux des structures

Chapitre 5 : Structures et tableaux des structures



A) Le type structure :



1) Domaines d'utilisation :


Le type structure se trouve dans les structures de données
suivantes :

- tableau de structures
- liste linéaire chaînée, arbre binaire
- fichier non texte
- classe (programmation orientée objet)
- etc ...



2) Introduction :


Le type structure (struct) en C est semblable au type
enregistrement (record) dans le langage PASCAL (cours IFT 1140).
C'est une collection des champs qui peuvent être de types
différents.

Exemple :

Une personne est une structure avec les champs possibles suivants :

- nom et prénom : chaîne de caractères
- taille et poids : réels
- âge : entier
- sexe : caractère
- etc ...

Grâce à ce type, on peut réduire le nombre de tableaux à traiter
dans un programme :

Pour la gestion des notes du cours IFT 1160 :

1. Avec les tableaux à un seul indice, on a besoin des tableaux
suivants :

nomPre : tableau des chaînes de caractères
numero : tableau des entiers (numéros d'inscription)

intra, final, tp1, tp2, tp3, tps, globale : 7 tableaux des
réels

code : tableau des chaînes de caractères ("A+", "C-
",...)

Au total, on a 10 tableaux à déclarer, à écrire sur les
en-têtes des fonctions et des appels. De plus, quand on
fait l'échange dans le tri, il faut utiliser 3 affectations
par tableau. Avec ces 10 tableaux, ces échanges nécessitent
10 x 3 = 30 affectations. C'est long à écrire.

2. Avec les tableaux à deux indices, on peut réduire sensiblement
le nombre de tableaux à traiter :


nomPre : tableau des chaînes de caractères
numero : tableau des entiers (numéros d'inscription)
note : un seul tableau à 2 indices
code : tableau des chaînes de caractères ("A+", "C-
",...)

Au total, on a 4 tableaux à déclarer, à manipuler sur les
en-têtes des fonctions et des appels. Pour le tri, on a
besoin de 12 (4 x 3) affectations afin d'échanger les
informations.

3. Avec le type structure, il est possible d'utiliser un seul
tableau : tableau des étudiants, chaque élément de ce tableau
est une variable de type structure. On a ainsi un seul tableau
à déclarer et à manipuler.


Plus tard dans le cours, on utilisera le type "struct" dans les
listes linéaires chaînées, les arbres binaires, les fichiers
non textes, ...


3) Déclaration et terminologie :


Supposons qu'on désire déclarer deux variables pers1 et pers2
de type structure et que chaque personne dispose de quatre
informations :

- numéro : un entier
- taille et poids : deux réels
- sexe : un caractère.

a) Façon 1 : déclaration directe sans le nom du type structure.

struct
{
int numero ;
float taille, poids ;
char sexe ;
} pers1, pers2 ;

Le désavantage de cette manière de faire est qu'il n'est
pas
flexible pour la déclaration de nouvelles variables de même
type
structure que nous aimerions utiliser ailleurs dans un même
programme.


Schéma d'une structure :


+-------------+-------+--------+-----+
pers1 | 1325 | 1.75 | 67.9 | 'M' |
+-------------+-------+--------+-----+
+-------------+-------+--------+-----+
pers2 | 6548 | 1.67 | 57.3 | 'F' |
+-------------+-------+--------+-----+

b) Façon 2: déclaration avec le nom du type structure.

b.1) on déclare d'abord le type :

struct personne
{
int numero ;
float taille, poids ;
char sexe ;
} ;


b.2) on déclare après les variables :

struct personne pers1, pers2 ;

Si on veut déclarer d'autres informations de ce type,
il suffit de se référer au type "struct personne" :

Exemples :

1) void Afficher ( struct personne unePers )
/* afficher les informations d' "unePers" qui est
de type struct personne */


2) struct personne tempo ; /* une autre variable de
même type */

etc ...



c) Façon 3: déclarer en même temps le type et les variables:


struct personne
{
int numero ;
float taille, poids ;
char sexe ;

} pers1, pers2 ;


d) Façon 4: déclarer en utilisant "typedef" :

typedef struct {

int numero ;
float taille, poids ;
char sexe ;

} Personne ; /* personne est le nom du type */

Personne pers1, pers2 ;

Remarques :


1. Pour le cours IFT 1160, on vous suggère fortement d'utiliser
la 4 ième façon.

2. Avec la déclaration selon la 4 ième façon :

a) Personne est le nom du type structure qui
dispose de 4 champs d'information.

b) numero est le nom d'un champ de type entier.
taille et poids sont deux champs de type réels.
sexe est un champ de type caractère.

c) pers1 et pers2 sont deux variables de type structure dont
le nom est Personne.


3. Le C++ permet de simplifier les déclarations :


struct Personne
{ int numero ;
float taille, poids ;
char sexe ;
};

Personne pers1, pers2 ;


Exemple :

Écrire les déclarations d'une variable "unEtud" de type "Etudiant"
pour la gestion de ses notes.

Solution :

#define LONG_NP 30 /* 30 caractères pour le nom et le prénom
*/
#define NB_NOTES 7 /* 7 notes */
#define LONG_CODE 2 /* 2 caractères pour le code littéral "B+"
...*/

typedef struct
{ char nomPre [LONG_NP +1] ;
int numIns ;

float note[NB_NOTES] ;

char code[LONG_CODE+1] ;
}
Etudiant ;

Etudiant unEtud ;

Exercice :

Écrire les déclarations d'une variable "unEmp" de type "Employe"
qui comporte les champs d'informations suivantes :

- nom et prénom
- numéro d'employé
- numéro d'assurance sociale
- âge
- salaire hebdomadaire
- poste de travail (parmi les postes : analyste, programmeur,
opérateur, secrétaire)


4) Manipulation du type structure :



4.1) Accès à un champ d'une structure :


Comme en langage PASCAL, le C utilise aussi le point "." pour
accéder à un champ d'une variable de type structure :

variable_de_type_structure . champ

Exemples :

1. Écrire les instructions pour donner à la "pers1" les
informations suivantes :

C'est un homme qui mesure 1.67 mètre et pèse 67.8 kgs.
Son numéro d'identification est le 7234.


pers1.numero = 7234 ;
pers1.sexe = 'M' ;
pers1.taille = 1.67 ;
pers1.poids = 67.8 ;
2. Écrire les instructions pour afficher les informations
de "pers1" à l'écran :

printf("Son numéro : %6d\n", pers1.numero);
printf("Son sexe : %6c\n", pers1.sexe);
printf("Son poids : %6.2f kgs\n", pers1.poids);
printf("Sa taille : %6.2f m\n", pers1.taille);


Cas spécial : Pointeur vers le type structure :


Avec la déclaration : Personne * P ;

P est un pointeur vers le type Personne.

*P est une variable de type Personne.

On peut accéder à n'importe quel champ de *P :

(*P).taille, (*P).poids, etc ....

Le C permet de simplifier l'écriture en utilisant l'opérateur ->


(*P).champ P->champ



4.2) Affectation entre deux variables de type structure :



Avec Personne pers1, pers2 ; on peut affecter l'une à l'autre :

pers1 = pers2 ; /* pers1 contiendra toutes les informations
de pers2. */

Exemple :

Écrire une fonction permettant d'échanger les informations de
deux personnes (de type Personne) :


Solution :

void echanger ( Personne * P1, Personne * P2)
{
Personne Temporaire ;

temporaire = *P