Déclarations de structure

Une « déclaration de structure » nomme un type et spécifie une séquence de valeurs de variable (appelées « membres » ou « champs » de la structure) qui peuvent avoir différents types. Un identificateur facultatif, appelé « balise », donne le nom du type de structure et peut être utilisé dans les références suivantes au type de structure. Une variable de ce type de structure contient la séquence entière définie par ce type. Les structures en C sont similaires aux types appelés « enregistrements » dans d’autres langages.

Syntaxe

struct-or-union-specifier :
  struct-or-union identifier _opter{struct-declaration-list}
  struct-or-union identifier

struct-or-union :
 struct
 union

struct-declaration-list :
 struct-declaration
  struct-declaration-list struct-declaration

struct-declaration :
  specifier-qualifier-list struct-declarator-list ;

specifier-qualifier-list :
  type-specifier specifier-qualifier-list _opter
  type-qualifier specifier-qualifier-list _opter

struct-declarator-list :
  struct-declarator struct-declarator-list , struct-declarator

struct-declarator :
 declarator
  type-specifier declarator _opter:constant-expression

La déclaration d’un type de structure ne met pas d’espace de côté pour une structure. Il s’agit uniquement d’un modèle pour les déclarations ultérieures de variables de structure.

Une balise précédemment définie identifier peut être utilisée pour faire référence à un type de structure défini ailleurs. Dans ce cas, struct-declaration-list ne peut pas être répété tant que la définition est visible. Les déclarations de pointeurs vers des structures et des typesdefs pour les types de structure peuvent utiliser la balise de structure avant la définition du type de structure. Toutefois, la définition de structure doit être rencontrée avant toute utilisation réelle de la taille des champs. Cette utilisation est une définition incomplète du type et de la balise de type. Pour que cette définition soit terminée, une définition de type doit apparaître plus loin dans la même étendue.

Spécifie struct-declaration-list les types et noms des membres de la structure. Un struct-declaration-list argument contient une ou plusieurs déclarations de variable ou de champ binaire.

Chaque variable déclarée est struct-declaration-list définie en tant que membre du type de structure. Les déclarations de variable au sein struct-declaration-list ont le même formulaire que d’autres déclarations de variables décrites dans cette section, sauf que les déclarations ne peuvent pas contenir de spécificateurs de classe de stockage ou d’initialiseurs. Les membres de la structure peuvent avoir n’importe quel type de variable, à l’exception du type void, d’un type incomplet ou d’un type de fonction.

Un membre ne peut pas être déclaré pour avoir le type de la structure dans laquelle il apparaît. Toutefois, un membre peut être déclaré comme pointeur vers le type de structure dans lequel il apparaît tant que le type de structure a une balise. Il vous permet de créer des listes liées de structures.

Les structures suivent la même étendue que d’autres identificateurs. Les identificateurs de structure doivent être distincts d’autres balises de structure, d’union et d’énumération avec la même visibilité.

Chacun struct-declaration d’eux struct-declaration-list doit être unique dans la liste. Toutefois, les noms d’identificateurs dans un struct-declaration-list n’ont pas besoin d’être distincts des noms de variables ordinaires ou des identificateurs d’autres listes de déclaration de structure.

Les structures imbriquées sont également accessibles comme si elles ont été déclarées au niveau de l’étendue du fichier. Par exemple, étant donné cette déclaration :

struct a
{
    int x;
    struct b
    {
      int y;
    } var2;
} var1;

ces déclarations sont légales :

struct a var3;
struct b var4;

Exemples

Ces exemples illustrent les déclarations de structure :

struct employee   /* Defines a structure variable named temp */
{
    char name[20];
    int id;
    long class;
} temp;

La employee structure a trois membres : name, idet class. Le name membre est un tableau de 20 éléments et idclass est un membre simple avec int et long un type, respectivement. L’identificateur employee est l’identificateur de structure.

struct employee student, faculty, staff;

Cet exemple définit trois variables de structure : student, facultyet staff. Chaque structure a la même liste de trois membres. Les membres sont déclarés pour avoir le type employeede structure défini dans l’exemple précédent.

struct           /* Defines an anonymous struct and a */
{                /* structure variable named complex  */
    float x, y;
} complex;

La complex structure a deux membres avec float type et xy. Le type de structure n’a aucune balise et n’est donc pas nommé ou anonyme.

struct sample   /* Defines a structure named x */
{
    char c;
    float *pf;
    struct sample *next;
} x;

Les deux premiers membres de la structure sont une char variable et un pointeur vers une float valeur. Le troisième membre, est nextdéclaré comme pointeur vers le type de structure défini (sample).

Les structures anonymes peuvent être utiles lorsque le nom de la balise n’est pas nécessaire, par exemple quand une déclaration définit toutes les instances de structure. Par exemple:

struct
{
    int x;
    int y;
} mystruct;

Les structures incorporées sont souvent anonymes.

struct somestruct
{
    struct    /* Anonymous structure */
    {
        int x, y;
    } point;
    int type;
} w;

Spécifique à Microsoft

Le compilateur autorise un tableau non dimensionné ou de taille zéro comme dernier membre d’une structure. Il est utile si la taille d’un tableau constant diffère lorsqu’elle est utilisée dans différentes situations. La déclaration d’une telle structure ressemble à ceci :

struct identifier { set-of-declarations type array-name []; };

Les tableaux non structurés ne peuvent apparaître que comme dernier membre d’une structure. Les structures contenant des déclarations de tableau non converties peuvent être imbriquées dans d’autres structures tant qu’aucun autre membre n’est déclaré dans des structures englobantes. Les tableaux de ces structures ne sont pas autorisés. L’opérateur sizeof , lorsqu’il est appliqué à une variable de ce type ou au type lui-même, suppose 0 pour la taille du tableau.

Les déclarations de structure peuvent également être spécifiées sans déclarateur lorsqu’elles sont membres d’une autre structure ou union. Les noms de champs sont promus dans la structure englobante. Par exemple, une structure sans nom ressemble à ceci :

struct s
{
    float y;
    struct
    {
        int a, b, c;
    };
    char str[10];
} *p_s;
.
.
.
p_s->b = 100;  /* A reference to a field in the s structure */

Pour plus d’informations sur les références de structure, consultez Structure et Membres de l’union.

FIN de la section spécifique à Microsoft

Voir aussi

Déclarateurs et déclarations de variables