Les structures

Avatar de Monsieur X
Description du chapitre et des ses objectifs :

Toujours dans le thème du format de donnée, je demande la structure. Contrairement aux tableaux qui servent à stocker x même type de nombres, la structure permet elle de faire un raccourcis entre plusieurs types différents permettant de décrire un objet.

Image de Partie

Accéder directement à une des parties du cours :

Déclaration d'une structure

Il faut imaginer une structure comme un paquet de variables contenues sous le nom d'une seule. Vous pourrez y mettre tout ce que vous voulez: tableaux, entiers, nombre décimaux ou même d'autres structures. La structure devient ainsi un type de variable à l'instar d'un int ou float. La déclaration d'une structure est spécifique, voici le schéma type:

Code c - Numéro de ligne
  1. struct <nom_structure>{
  2.      /* variables que l'on souhaite */
  3.      int  nombre1;
  4.      float ce_nombre;
  5.      char nom[10];
  6. };



Comme vous pouvez le constater, toute structure déclarée est précédé du mot clef struct. Suivit du nom de la structure, par exemple ici on aurait pu l'appeler ma_structure (original non?). Ensuite, on met ce que l'on veut dedans. Attention cependant, il est interdit d'affecter un nombre à une variable dans la déclaration d'un structure. En effet, c'est seulement lorsque l'on va déclarer une variable du type de cette structure que l'on pourra affecter des valeurs (et bien entendu utiliser la stucture comme on le souhaite). Toutes les variables contenues dans la structure seront englobées dans des accolades, on appelle ces variables les champs d'une structure.

Attention : On oublie pas de mettre un ";" à la fin de la structure!



Une chose à savoir: la déclaration d'une structure peut se faire dans une fonction ou en dehors. La différence est que si elle est déclarée dans une fonction spécifique, elle ne pourra être utilisée que dans celle-ci, l'intérêt est donc limité. Une structure est donc généralement déclarée à l'extérieur de toute fonction (après les includes) et pourra être ainsi utilisée dans toutes les fonctions.

Utilisation d'une structure

Voici le point principal des structures. L'utilisation est globalement assez simple vous allez voir.
Tout d'abord il faut déclarer une variable du type de la structure. Pour cela, il faut mettre le mot clef struct suivit du nom de la structure et enfin le nom de la variable.

Code c - Numéro de ligne
  1. struct <nom_sructure> <nom_variable>;


Pour accéder à chaque champ de la structure (variables contenues dans la structure), il suffit de placer un point entre le nom de la variable et le nom du champ de la structure.
Code c - Numéro de ligne
  1. <nom_variable>.<champ_structure>;


Ensuite, vous pouvez utiliser chacun des champs comme une variable classique. Voici un exemple complet sur l'utilisation de structures:
Code c - Numéro de ligne
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. struct maison
  5. {
  6.     char nom_rue[50];
  7.     int numero;
  8. };
  9.  
  10. int main(void)
  11. {
  12.     struct maison ma_maison;
  13.     printf("Numero de la maison? ");
  14.     scanf("%d", &amp;ma_maison.numero);
  15.     printf("\nNom de la rue? ");    
  16.     scanf("%s", &amp;ma_maison.nom_rue[0] );
  17.     printf("\nVous habitez au %d de la rue %s\n", ma_maison.numero, &amp;ma_maison.nom_rue[0]);
  18.     return 0;
  19. }


Si vous avez une structure à l'intérieur de votre structure, pour y accéder il suffit encore une fois de mettre un point "." pour accéder à ses champs. Par exemple, une structure A contenant le champ: struct B b; Il suffirait de déclarer une variable de type A:
Code c - Numéro de ligne
  1. struct A a; //dans le main
et pour accéder aux membres de b:
Code c - Numéro de ligne
  1. a.b.<champ>
C'est un peu moche à expliquer, mais il suffit juste de mettre tout le temps des "." pour accéder à telle ou telle structure.



Comme tout type de variable, il est aussi possible de faire un tableau de structure. Cela se passe à la déclaration de notre tableau, en reprennant l'exemple de la structure maison:
Code c - Numéro de ligne
  1. maison village[50]; //déclaration de notre tableau de "maison"
  2. village[10].numero = 42 ; //accès au champbnumero de la structure "maison"
Rien d'insurmontable donc

Enlever le struct?

S'il existe une chose bien ennuyeuse, c'est bien de devoir à chaque fois taper struct devant une structure pour déclarer une variable. Pour remédier à cela, on a inventé le typedef! C'est un mot clef simple d'utilisation.
Imaginons la structure:

Code c - Numéro de ligne
  1. struct machin{
  2. int a;
  3. ;

Il suffit d'ajouter cette ligne:
Code c - Numéro de ligne
  1. typedef struct machin machin;

Lorsque vous déclarerez une variable de type machin, vous n'aurez qu'a faire:
Code c - Numéro de ligne
  1. machin variable;
et finit le struct à tout bout de champ.

Vous pouvez aussi changer le nom par lequel vous pouvez appeller cette structure, par exemple:
Code c - Numéro de ligne
  1. typedef struct machin truc;
Permettra de déclarer une variable de cette façon:
Code c - Numéro de ligne
  1. truc variable;


Une autre façon on peu moins lourde d'utiliser le typedef consiste à "l'intégrer" dans la définition de la structure:
Code c - Numéro de ligne
  1. typedef struct{
  2.     int a;
  3. } machin;


Remarquez la transformation: On déplace le nom de la structure après l'accolade fermante et on met le ";" à la fin. Inutile de rajouter d'autres lignes, la déclaration de la variable se fait de cette façon:
Code c - Numéro de ligne
  1. machin variable;


Sympa non?

A noter qu'il est possible de donner plusieurs noms à une même structure en séparant par une virgule chaque nom donné avec un typedef. Par exemple:
Code c - Numéro de ligne
  1. typedef struct{
  2.     int a;
  3. } machin, truc, bidule;

Initialisation rapide

Comme pour un tableau, il est possible d'utiliser la technique des accollades {} pour initialiser rapidement une structure.
Imaginons une structure déclarée de cette façon:

Code c - Numéro de ligne
  1. typedef struct{
  2.     int a;
  3.     int b;
  4.     int c;
  5. } test;


Vous pouvez initialiser une variable de type test de cette façon:
Code c - Numéro de ligne
  1. test variable = {1,2,3};


Attention : Les champs prendrons EXACTEMENT la valeur qui leur correspond dans l'ordre dans lequel les champs ont été déclarés. Ceci signifie que variable.a=1 , variable.b=2 , variable.c=3.

Et comme pour les tableaux, les variables qui n'ont pas été initialisées dans les crochets prendront la valeur 0.

Les unions

Il existe un format de stockage proche de la structure nommé union. Ce format est un peu obselète étant donné la taille actuelle moyenne des mémoires. En effet, les unions permettent "en gros" de stocker les champs d'une union sur la taille du champ le plus grand. Ne pas comprendre cela n'est pas un grand problème. Pour commencer, les unions se déclarent de la même façon que les structures excepté qu'il faut remplacer le mot clef struct par union.
Voici un exemple d'union:

Code c - Numéro de ligne
  1. typedef union{
  2.    int a;
  3.    double b;
  4. } Union_test;


On accède exactement de la même façon à chaque membre de l'union:
Code c - Numéro de ligne
  1. Union_test foo;
  2. foo.a = 18;
  3. foo.b = 5.5;


Le problème est que lorsque vous faites: foo.a = 18; Cela revient à mettre foo.a dans l'espace mémoire de foo.b. La taille d'une union est donc la taille du plus grand de ses champs. Dans notre exemple, la taille est celle d'un double. En fait, c'est plus compliqué à utiliser proprement que ça aide.
Pour mieux comprendre ce qu'il se passe, rien de mieux qu'un exemple:
Code c - Numéro de ligne
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. typedef union{
  5.    int a;
  6.    double b;
  7. } Union_test;
  8.  
  9. int main(void)
  10. {    
  11.     Union_test foo={0};
  12.     foo.a = 18;
  13.     printf("foo.a vaut %d et foo.b vaut %lf\n", foo.a, foo.b);
  14.     foo.b = 5.5;
  15.     printf("foo.a vaut %d et foo.b vaut %lf\n", foo.a, foo.b);
  16.     return 0;
  17. }


Donne:
Code dos - Numéro de ligne
  1. foo.a vaut 18 et foo.b vaut 0.000000
  2. foo.a vaut 0 et foo.b vaut 5.500000


Chaque champ écrase l'autre. C'est donc en fait comme si l'on travaillait sur un double qui porte plusieurs noms.

Voilà une bonne chose inutile d'apprise, mais bon, il faut quand même connaître. (je m'excuse auprès des grands maîtres de la programmation qui adorent les unions pour qui mes propos semblent diffamatoires)

Et voilà, vous n'aurez plus à tout séparer, vous pourrez créer des groupes de variables pour désigner des objets et leur attribuer plein de données. A vous les agendas comprennant age/adresse/numero de téléphone et j'en passe.

Chapitre précédent - Sommaire - Chapitre suivant

Nos rédacteurs et membres sont pour la plupart ouverts à des remarques constructives et servir à alerter le rédacteur du cours, des fautes éventuelles ou de propositions et nouvelles perspectives de cours etc ...
Pour ce faire cliquez ici

Postez vous aussi un commentaire à cette partie via le lien que voici