Programmation en C – Les structures

Les tableaux permettent de définir le type de variables qui peut contenir plusieurs éléments de données du même type. De même, une structure est un autre type de données défini par l’utilisateur  qui permet de combiner des éléments de type différents.
 
 

Définir une structure

Pour définir une structure, vous devez utiliser l’instruction struct. L’instruction struct définit un nouveau type de données avec plusieurs membres. Le format de l’instruction struct est le suivant

struct [tag] {
   membre 1;
   membre 2;
   …
   membre n;
} [une ou plusieurs variables];  

La balise [tag] est facultative et chaque définition de membre est une définition de variable normale, telle que int i; ou float f; ou toute autre définition de variable valide. À la fin de la définition de la structure, avant le point-virgule final, vous pouvez spécifier une ou plusieurs variables de structure, mais cette option est facultative. Voici comment vous pouvez déclarer une structure en C.

struct Livres {
   char  titre[50];
   char  auteur[50];
   char  sujet[100];
   int   livre_id;
} livre;   

Accès aux membres de la structure

Pour accéder à n’importe quel membre d’une structure, nous utilisons l’opérateur « . ». L’opérateur d’accès d’un membre est codé comme un point entre le nom de la variable de structure et le membre de structure auquel nous souhaitons accéder. Vous utiliseriez le mot-clé struct pour définir les variables du type de structure. L’exemple suivant montre comment utiliser une structure dans un programme

#include <stdio.h>
#include <string.h>
 
struct Livres {
   char  titre[50];
   char  auteur[50];
   char  sujet[100];
   int   livre_id;
} livre; 
 
int main( ) {

   struct Livres livre1;        /* Déclare livre1 de type Livre */
   struct Livres  livre2;        /* Déclare livre2 de type Livre */
 
   /* livre 1 spécification*/
   strcpy( livre1.titre, "Programmation C");
   strcpy( livre1.auteur, "Yaka MainProgramming"); 
   strcpy( livre1.sujet, "Les structures en C");
   livre1.livre_id= 6495407;

   /* livre 2 spécification*/
   strcpy( livre2.titre, "Programmation C++");
   strcpy( livre2.auteur, "AWER MainProgramming");
   strcpy( livre2.sujet, "Les structures en C++");
   livre2.livre_id= 14598759;
 
   /* afficher les informations du livre1 */
   printf( "Livre 1 titre: %sn", livre1.titre);
   printf( "Livre 1 auteur: %sn", livre1.auteur);
   printf( "Livre 1 subject : %sn", livre1.sujet);
   printf( "Livre 1 livre_id: %dn", livre1.livre_id );

   /* afficher les informations du livre2 */
   printf( "Livre 2 titre: %sn", livre2.titre);
   printf( "Livre 2 auteur: %sn", livre2.auteur);
   printf( "Livre 2 sujet: %sn", livre2.sujet);
   printf( "Livre 2 livre_id: %dn", livre2.livre_id);

   return 0;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant:

Livre 1 titre: Programmation C
Livre 1 auteur: Yaka MainProgramming
Livre 1 subject : Les structures en C
Livre 1 livre_id: 6495407
Livre 2 titre: Programmation C++
Livre 2 auteur: AWER MainProgramming
Livre 2 sujet: Les structures en C++
Livre 2 livre_id: 14598759

Structures en tant qu’arguments de fonction

Vous pouvez passer une structure en tant qu’argument à une fonction comme vous passez une variable.

#include <stdio.h>
#include <string.h>
 
struct Livres {
   char  titre[50];
   char  auteur[50];
   char  sujet[100];
   int   livre_id;
} livre; 
 
/* déclaration de fonction */
void afficherLivre( struct Livres livre );
 
int main( ) {

   struct Livres livre1;        /* Déclare livre1 de type Livre */
   struct Livres  livre2;        /* Déclare livre2 de type Livre */
 
   /* livre 1 spécification*/
   strcpy( livre1.titre, "Programmation C");
   strcpy( livre1.auteur, "Yaka MainProgramming"); 
   strcpy( livre1.sujet, "Les structures en C");
   livre1.livre_id= 6495407;

   /* livre 2 spécification*/
   strcpy( livre2.titre, "Programmation C++");
   strcpy( livre2.auteur, "AWER MainProgramming");
   strcpy( livre2.sujet, "Les structures en C++");
   livre2.livre_id= 14598759;
 
   /* afficher les informations du livre1 */
    afficherLivre( livre1 );

   /* afficher les informations du livre2 */
    afficherLivre( livre2 );

   return 0;
}

void afficherLivre( struct Livres livre ) {
    
   printf( "Livre titre: %sn", livre.titre);
   printf( "Livre auteur: %sn", livre.auteur);
   printf( "Livre sujet: %sn", livre.sujet);
   printf( "Livre livre_id: %dn", livre.livre_id);
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Livre titre: Programmation C
Livre auteur: Yaka MainProgramming
Livre sujet: Les structures en C
Livre livre_id: 6495407
Livre titre: Programmation C++
Livre auteur: AWER MainProgramming
Livre sujet: Les structures en C++
Livre livre_id: 14598759

Pointeurs vers les structures

Vous pouvez définir des pointeurs vers des structures de la même manière que vous définissez le pointeur vers une autre variable

Vous pouvez maintenant stocker l’adresse d’une variable de structure dans la variable de pointeur définie ci-dessus. Pour trouver l’adresse d’une variable de structure, placez le ‘&’ opérateur avant le nom de la structure comme suit

Pour accéder aux membres d’une structure en utilisant un pointeur vers cette structure, vous devez utiliser l’opérateur → comme suit

Réécrivons l’exemple ci-dessus en utilisant un pointeur de structure.

#include <stdio.h>
#include <string.h>
 
struct Livres {
   char  titre[50];
   char  auteur[50];
   char  sujet[100];
   int   livre_id;
}; 
 
/* déclaration de fonction */
void afficherLivre( struct Livres *livre );
 
int main( ) {

   struct Livres livre1;        /* Déclare livre1 de type Livre */
   struct Livres  livre2;        /* Déclare livre2 de type Livre */
 
   /* livre 1 spécification*/
   strcpy( livre1.titre, "Programmation C");
   strcpy( livre1.auteur, "Yaka MainProgramming"); 
   strcpy( livre1.sujet, "Les structures en C");
   livre1.livre_id= 6495407;

   /* livre 2 spécification*/
   strcpy( livre2.titre, "Programmation C++");
   strcpy( livre2.auteur, "AWER MainProgramming");
   strcpy( livre2.sujet, "Les structures en C++");
   livre2.livre_id= 14598759;
 
   /* afficher les informations du livre1 */
    afficherLivre( &livre1 );

   /* afficher les informations du livre2 */
    afficherLivre( &livre2 );

   return 0;
}

void afficherLivre( struct Livres *livre ) {
    
   printf( "Livre titre: %sn", livre->titre);
   printf( "Livre auteur: %sn", livre->auteur);
   printf( "Livre sujet: %sn", livre->sujet);
   printf( "Livre livre_id: %dn", livre->livre_id);
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Livre titre: Programmation C
Livre auteur: Yaka MainProgramming
Livre sujet: Les structures en C
Livre livre_id: 6495407
Livre titre: Programmation C++
Livre auteur: AWER MainProgramming
Livre sujet: Les structures en C++
Livre livre_id: 14598759

Champs de bits

Les champs de bits permettent l’empilement de données dans une structure. Ceci est particulièrement utile lorsque la mémoire ou le stockage de données est essentiel. Des exemples typiques comprennent :

Emballer plusieurs objets dans un mot machine. par exemple. Les drapeaux de 1 bit peuvent être compactés.

Lecture des formats de fichiers externes – formats de fichier non standard pourraient être lus, par exemple, des entiers de 9 bits.

C nous permet de le faire dans une définition de structure en mettant: longueur de bit après la variable. Par exemple

struct boxes {
   unsigned int fl1:1;
   unsigned int fl2:1;
   unsigned int fl3:1;
   unsigned int fl4:1;
   unsigned int type:4;
   unsigned int entier:9;
} boxe;

Ici, le fichier boxes contient 6 membres: quatre indicateurs de 1 bit fl1..fl3, un type de 4 bits et un entier de 9 bits.

C compresse automatiquement les champs de bits ci-dessus de façon aussi compacte que possible, à condition que la longueur maximale du champ soit inférieure ou égale à la longueur du mot entier de l’ordinateur. Si ce n’est pas le cas, alors certains compilateurs peuvent autoriser le chevauchement de la mémoire pour les champs tandis que d’autres vont stocker le champ suivant dans le mot suivant.