Les structures :

Une structure est une collection de variables pouvant être de types différents, groupées sous un seul nom. Les variables au sein de la structure sont appelées les membres de cette structure. L’accès à chacune d’entre-elles se fera non pas par sa position, mais directement par son nom.

Propriétés:

• Une structure peut contenir n’importe quelle quantité de membres ;
• Les membres peuvent être de n’importe quel type ;
• Une structure permet à un groupe de variables d’être utilisées comme une simple unité,même lorsqu’elles sont de types différents ;
• Une structure facilite l’organisation des données complexes.

Déclaration d’une structure :

struct nomDeStructure
    {
       type1 nomMembre1 ;
       type2 nomMembre2 ;
	     .
	     .
	     .
       typeN nomMembreN;
     }

Les membres de la structure sont déclarés comme de simples variables.

Exemple :

// Structure de traitement des nombres complexes
struct nBcomplexe
 {
    float re ;    //partie réelle
    float im ;   //partie imaginaire
    float module ;
 }

La déclaration dans cet exemple n'en est pas une à proprement parler; dans un premier temps, on définit le nom du modèle de la structure qui s’appelle ici complexe, mais il n' y a pas de réservation de variables qui correspondent à cette structure.

Une fois le modèle de la structure définit, on peut déclarer les variables du type correspondant :

Par exemple :

struct nBcomplexe x ;

Cette instruction réserve un emplacement de type nBcomplexe x destiné à contenir trois flottants.

Plusieurs emplacements de types nBcomplexe peuvent être réservés avec une seule déclaration :

struct nBcomplexe x, y ;

Il est aussi possible de regrouper la définition du modèle de structure et la déclaration de type de variables dans une seule instruction.

Exemple :

// Structure de traitement des nombres complexes
struct nBcomplexe
 {
    float re ;    //partie réelle
    float im ;   //partie imaginaire
    float module ;
 } x, y ;

Dans ce type de déclaration, le nom du modèle peut être omis, si d’autres variables ne sont pas à déclarer par la suite dans le programme.

Utilisation des membres d’une structure :

Une fois la structure déclarée, chacun de ses membres peut être manipulé comme n’importe quelle variable de type correspondant. On fait suivre le nom de la variable structure par l’opérateur « • », puis le nom du membre tel qu’il a été définit dans le modèle :

Par exemple : 

x.re = 1.62 ;
x.im = 0.57 ;
printf("%f\n", x.module) ;

Il est possible d’affecter à une structure, le contenu d’une autre structure définie à partir du même modèle.

Par exemple si x et y on été déclarées comme étant de types complexe, on peut affecter y à x en écrivant :  x = y ;

Cela évite d'écrire par exemple:  x.re = y.re ; x.im = y.im ; ...etc.

Initialisation d’une structure:

Elle respecte le règles en vigueur pour tout type de variable en la matière :

Sans initialisation explicite, le contenu de la variable est égal à 0 ;

Initialisation possible lors de la déclaration.

Par exemple pour initialiser x :

struct complexe x = {1.62, 0.57, 1.72} ;

Autres exemple d’utilisation avec des chaînes de caractères :

struct stringExple
 {
    char x[6] ;
    char *y ;
 } str ;
//
int main(void)
 {
    str.x[0] = ‘H’ ;
    str.x[1] = ‘e’ ;
    str.x[2] = ‘l’ ;
    str.x[3] = ‘l’ ;
    str.x[4] = ‘o’ ;
    str.x[5] = ‘\0’ ;
//
   str.y = "world" ;
 }

Les champs de bits :

Dans le paragraphe dédié aux opérateurs, nous avons vu que le langage C dispose d’opérateurs puissants pour travailler au niveau du bit. Pour compacter une information numérique ou analyser un motif binaire, on peut utiliser les champs de bits.

Les champs de bits sont des membres des structures, qui occupent un nombre spécifié de bits adjacents dont la taille peut varier de 1 jusqu’à la taille d'un type entier (type int).

Seuls les types int et unsigned int sont susceptibles d’apparaître dans les champs de bits.

Les champs de bits sont des membres d’une structure ordinaire,  ils ont un nombre de bits bien spécifiés et ils permettent d’accéder individuellement à chaque bits sans utiliser de masques sur les mots binaires.

Syntaxe :

struct nomStructure
 {
    unsigned int nomMembre1 : nombreDeBits ;
             .
             .
             .
    unsigned int nomMembreN : nombreDeBits ;
 }

Exemple :

// Definition de la structure champs de bits
struct InOutPort
 {
     unsigned int bit0 :1 ; // reserve 1 bit
     unsigned int bit1 :1 ; // reserve 1 bit
     unsigned int bit2 :1 ; // reserve 1 bit
     unsigned int bit3 to bit4 :3 ; // reserve 3 bits
     unsigned int bit5 :1 ; // reserve 1 bit
     unsigned int bit6 :1 ; // reserve 1 bit
     unsigned int bit7 :1 ; // reserve 1 bit
 } ;
// Declaration
struct InOutPort portInput ;

Utilisation d’un champ de bits :

struct portInput
 {
    unsigned a :1 ;
    unsigned b :1 ;
    unsigned c :2 ;
    unsigned d :1 ;
    unsigned e :3 ;
 } x ;
int main(void)
 {
    x.a = 1 ;
    x.b = 0 ;
    x.c  = 0b10 ;
    x.d  = 0 ;
    x.e = 7 ;
 }

La figure ci-après illustre l'exemple pour la structure portInput: