La définition des champs est analogue à la définition de variables (attention à ne pas oublier le point virgule à la fin de la définition) :

struct complexe {  double reel, imag; }; struct complexe x, y; /* deux complexes x et y */

 Cela peut s'écrire également :

struct complexe { double reel, imag; } x, y; ou encore struct { double reel, imag; } x, y; /* réutilisation impossible par la suite */

 Une référence à une structure peut être faite avant sa définition, à condition que sa taille ne soit pas nécessaire au compilateur :

struct Date { short jour, mois, an; }; struct Temps { short heure, minute, seconde; }; struct Instant {  struct Date date;  struct Temps temps; };

 La déclaration suivante référence une structure alors qu'elle n'est que partiellement définie :

struct chaine {  int maillon;  struct chaine *suivant; };

 En définissant un nouveau type, on peut éviter de répéter struct partout où le type structure est utilisé :

typedef struct chaine CHAINE; struct chaine {  int maillon;  struct chaine *suivant; }; CHAINE *s; s = (CHAINE *) malloc (10 * sizeof(CHAINE));

 Il est par contre impossible de définir des structures récursives infinies du type :

struct chaine {  int maillon;  struct chaine suivant; };

 Une structure peut être initialisée lors de sa définition de la même façon qu'un tableau :

struct Instant maintenant = { 1, 7, 1990, 9, 30, 0 }; ou struct Instant maintenant = { { 1, 7, 1990 }, { 9, 30, 0 } };

 L'opérateur . permet de référencer un champ dans une structure :

struct Date hier; hier.jour = 15: hier.mois = 7: hier.an = 2002: struct Instant moment[10]; moment[0].date.jour = 16; moment[0].date.mois = 7; moment[0].date.an = 2002; moment[0].date.heure = 1; moment[0].date.minute = 54; moment[0].date.seconde = 0;

 L'opérateur -> permet de référencer un champ à partir d'un pointeur de structure :

struct complexe *z; z = (struct complexe *) malloc (sizeof(struct complexe)); z->reel = 0.1; /* équivaut à (*z).reel = 0.1 */ z->imag = -.033;  /* équivaut à (*z).imag = 0.33 */

 L'opérateur = permet d'affecter une structure à une autre structure de même type. Par contre il n'est pas permis de comparer globalement deux structures avec l'opérateur == .




 Une structure peut être passée en paramètre à une fonction. Comme tout paramètre, elle est recopiée localement à l'entrée de la fonction.

struct tableau { int tab[20]; }; f (tableau); /* fournit à la fonction f une copie de la structure tableau */

 Une fonction peut retourner une structure :

typedef struct complex COMPLEX; COMPLEX init (double r, double i) {  COMPLEX nouveau;  nouveau.reel = r;  nouveau.imag = i;  return nouveau; } COMPLEX add (COMPLEX a, COMPLEX b) {  COMPLEX somme;  somme.reel = a.reel + b.reel;  somme.imag = a.imag + b.imag;  return somme; }

 Une structure peut avoir des champs plus petits que le type char, ce sont les champs de bits.

struct S {  unsigned a : 1,     b : 3,     c : 5;  int d; };

Cette déclaration définit S comme ayant un champ a d'un bit, un champ b de 3 bits, un champ c de 5 bits et un champ d entier. Les champs de bits sont toujours de type unsigned. Il est possible de laisser des espaces de remplissage après les champs de bits pour aligner le champ suivant :

struct S {  unsigned a : 1,     : 3, /* laisse un espace de 3 bits entre les champs a et c */     c : 5; };

 Le regroupement de ces champs ainsi que les espaces de remplissage dépendent de l'architecture de la machine. L'utilisation des champs de bits est non portable.

Retour en haut de page

Page suivante