En général, les types de base que propose le C ne suffisent pas pour stocker les données à utiliser dans un programme. Par exemple, il serait bien embêtant de devoir utiliser deux variables de type double pour stocker un nombre complexe. Heureusement le C permet de déclarer de nouveaux types. Nous ne ferons qu'évoquer les unions pour nous focaliser sur les structures qui permettent de répondre à la plupart des besoins.

 

déclaration d'une structure

      Une structure possède un nom et est composée de plusieurs champs. Chaque champ à son propre type et son propre nom. Pour déclarer un structure on utilise le mot-clé struct :

 

struct nomStructure {      type1 champ1;      ...      typeN champN;  } ;

Voici un exemple qui déclare une structure permettant de stocker un nombre complexe :

 

struct complex {      double reel; /* partie reelle */      double imag; /* partie imaginaire */  };

 

Il y a plusieurs méthodes possibles pour déclarer des structures.

Première méthode

La déclaration :

struct personne
   {
   char nom[20];
   char prenom[20];
   int no_employe;
   };

déclare l'identificateur personne comme étant le nom d'un type de structure composée de trois membres, 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é no_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;

 

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 no_employe;
   } p1,p2;

déclare deux variables de noms p1 et p2 comme étant deux structures de trois membres, mais elle ne donne pas de nom au type de la structure. L'inconvénient de cette méthode est qu'il sera par la suite impossible de déclarer une autre variable du même type. En effet, si plus loin on écrit :

struct
   {
   char nom[20];
   char prenom[20];
   int no_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;.

 

Troisième méthode

On peut combiner déclaration d'étiquette de structure et déclaration de variables, comme ceci :

struct personne
   {
   char nom[20];
   char prenom[20];
   int no_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 trois méthodes c'est la première qui est recommandée, car elle permet de bien séparer la définition du type structure de ses utilisations.

accès aux champs

    À partir de cette déclaration, il est possible d'utiliser ce nouveau type. L'opérateur . permet d'accéder à l'un des champs d'une structure. En continuant l'exemple précédent, les lignes suivantes initialisent un complexe à la valeur (2 + 3i).

 

struct complex a;        a.reel = 2;  a.imag = 3;

 

utilisation de typedef

    Le mot-clé typedef permet d'associer un nom à un type donné. On l'utilise suivi de la déclaration d'un type (en général une structure ou une union) puis du nom qui remplacera ce type. Ceci permet, par exemple, de s'affranchir de l'emploi de struct à chaque utilisation d'un complexe. Il n'est pas alors nécessaire de donner un nom à la structure. L'exemple précédent peut donc se réécrire de la manière suivante :

 

typedef struct {      double reel; /* partie reelle */      double imag; /* partie imaginaire */  } complexe;        complexe a;        a.reel = 2;  a.imag = 3;

 

initialisation et affectation

      Il est possible d'affecter une variable de type structure dans une autre variable du même type. Le contenu de chacun des champs de la première variable sera alors recopié dans le champ correspondant de la seconde variable. On peut initialiser une variable de type structure dès sa définition en lui affectant une liste de valeurs séparées par des virgules et entourées par des accolades.

 

complexe a = { 1, 0 }; /* le reel 1 */  complexe b;        b = a;

Il est par contre impossible de comparer ou d'effectuer des calculs entre deux structures.

 

exemple de structures imbriquées

On peut imbriquer plusieurs structures. Dans l'exemple suivant nous déclarons une structure pour stocker une commande d'un client contenant :

 

• la référence du produit commandé (refProd),
• une sous-structure (prix) stockant :
  • le prix unitaire hors taxe (HT),
  • le taux de TVA associé (TVA),
• le nombre d'unités commandées (q),
• la remise accordée en pourcentage (remise).

Cette structure se déclare de la manière suivante :

 

typedef struct {      int refProd; /* reference produit */      struct {          double HT; /* prix hors taxe */          double TVA; /* taux de TVA en pourcentage */      } prix;      int q; /* quantite commandee */      double remise; /* remise en pourcentage */  } commande;

Pour accéder aux champs de la sous-structure, il faut utiliser deux fois l'opérateur . d'accès aux champs. En supposant que com contienne une telle commande, voici le calcul du prix total :

 

double P_TTC, P_AvantRemise, P_Total;  P_TTC = com.prix.HT * (1 + com.prix.TVA / 100);  P_AvantRemise = P_TTC * com.q;  P_Total = P_AvantRemise - P_AvantRemise * com.remise / 100;

 

---

2017-10-15 16:08:46 / mazoughou@magoe.gn