Déclarations de structure

Une « déclaration de structure » désigne un type et spécifie une séquence de valeurs variables (appelées « membre » ou « champs » de la structure) qui peuvent avoir des types.Un identificateur facultatif, appelée une balise « , » indique 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 structure contient la séquence entière définie par ce type.Les structures dans C sont semblables aux types appelées « enregistrements » dans d'autres langages.

Syntaxe

• struct-ou-union-spécificateur:
  struct-déclaration-liste } optde**{** d'identificateur de struct-ou-union

  identificateur de struct-ou-union

• struct-ou-union:
  struct

  union

• struct-déclaration-liste:
  struct-déclaration

  struct-déclaration de struct-déclaration-liste

le contenu de structure est défini pour être

• struct-déclaration:
  struct-déclarateur-liste **;**de spécificateur-qualificateur-liste

• spécificateur-qualificateur-liste:
  spécificateur-qualificateur-liste de spécificateur de type opt

  spécificateur-qualificateur-liste de type-qualificateur opt

• struct-déclarateur-liste:
  struct-déclarateur

  struct-déclarateur deServeur IIS local de struct-déclarateur-liste

• struct-déclarateur:
  declarator

La déclaration d'un type structure ne met pas à côté de l'espace pour une structure.C'est uniquement un modèle pour les déclarations suivantes des variables de structure.

Un identificateur défini précédemment (indicateur) peut être utilisé pour faire référence à un type de structure défini ailleurs.dans ce cas, la struct-déclaration- liste ne peut pas être répétée tant que la définition est visible.Les déclarations des pointeurs vers les structures et typedef pour les types de structure peuvent utiliser l'indicateur de structure avant que le type de structure soit défini.Toutefois, la définition de structure doit être généré avant toute utilisation réelle de la taille des champs.Il s'agit d'une définition incomplète du type et l'indicateur de type.Pour que cette définition soit terminée, une définition de type doit figurer plus loin dans la même portée.

la struct-déclaration-liste spécifie les types et les noms des membres de structures.Un argument de struct-déclaration-liste contient un ou plusieurs des déclarations de variable ou champ de bits.

Chaque variable déclarée dans la struct-déclaration-liste est définie comme membre du type structure.Les déclarations de variable dans la struct-déclaration-liste ont le même formulaire que d'autres déclarations de variable décrites dans cette section, mais les déclarations ne peuvent pas contenir de spécificateurs ou les initialiseurs de classe de stockage.Les membres de structures peuvent avoir des types de variable à l'exception de le type void, un type incomplet, ou un type de fonction.

Un membre ne peut pas être déclaré pour avoir le type de la structure dans laquelle elle s'affiche.Toutefois, un membre peut être déclaré en tant que pointeur vers la structure dans laquelle il est tant que le type de structure a une balise.Cela vous permet de créer des listes liées de structures.

Les structures respectent la même portée que d'autres identificateurs.Les identificateurs de structure doivent être distincts d'autres structure, union, et indicateurs d'énumération avec la même visibilité.

chaque struct- déclaration dans une struct-déclaration- liste doit être unique dans la liste.Toutefois, les noms d'identificateurs dans une struct-déclaration-liste ne doivent pas ê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 avaient été déclarées au niveau de la portée du fichier.Par exemple, si cette déclaration :

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

ces déclarations sont tous deux valides :

struct a var3;
struct b var4;

Exemples

Ces exemples montrent les déclarations de structure :

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

la structure d' employee a trois membres : name, id, et class.Le membre d' name est un tableau de 20 éléments, et id et class sont des membres simples avec int et le type de long , respectivement.l'identificateur employee est l'identificateur de structure.

struct employee student, faculty, staff;

cet exemple définit trois variables de structure : student, faculty, et staff.chaque structure a la même liste de trois membres.Les membres sont déclarés comme ayant 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 structure d' complex possède deux membres avec le type, l' x et l' yde float .le type de structure n'a aucune balise et est donc sans nom 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 variable d' char et un pointeur vers une valeur float.Le troisième membre, next, est déclaré comme un pointeur vers le type de structure est défini (sample).

Les structures anonymes peuvent être utiles lorsque l'indicateur nommée n'est pas nécessaire.C'est le cas lorsqu'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 non dimensionné ou un tableau de taille zéro comme dernier membre d'une structure.Cela peut être utile si la taille d'un tableau constante est différent lorsqu'elle est utilisée dans des situations différentes.la déclaration d'une telle structure ressemble à ceci :

*identificateur ***{d'struct    définir-de-déclarations    nom de table[] ;} ;**de type

Les tableaux non dimensionnés peuvent apparaître comme dernier membre d'une structure.Les structures contenant des déclarations de tableau non dimensionné peuvent être imbriquées dans d'autres structures tant que un autre membre n'est déclaré dans aucune structure englobante.Vous ne pouvez pas utiliser de tableau de telles structures.L'opérateur d' sizeof , appliqué à une variable de ce type ou le type lui-même, utilise 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 structure ou union.Les noms de champ sont promus dans la structure englobante.par exemple, une structure inconnue 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 */

Consultez Structure et membres d'union pour plus d'informations sur les références de structure.

détail de FIN Microsoft

Voir aussi

Concepts

Déclarateurs et déclarations de variable