Dichiarazioni di struttura

Una "dichiarazione di struttura" denomina un tipo e specifica una sequenza di valori variabili (denominati "membri" o " campi" della struttura) con tipi differenti. Un identificatore facoltativo, denominato "tag," fornisce il nome del tipo di struttura e può essere utilizzato nei riferimenti successivi a tale tipo. Una variabile del tipo di struttura contiene l'intera sequenza definita dal tipo specificato. Le strutture in C sono simili ai tipi noti come "record" in altri linguaggi.

Sintassi

struct-or-union-specifier:
 struct-or-unionidentifier_Optare{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-specifierspecifier-qualifier-list_Optare
 type-qualifierspecifier-qualifier-list_Optare

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

struct-declarator:
 declarator
 type-specifierdeclarator_Optare:constant-expression

La dichiarazione di un tipo di struttura non riserva spazio per una struttura. Si tratta solo di un modello per le dichiarazioni successive di variabili di struttura.

Un oggetto definito in identifier precedenza (tag) può essere usato per fare riferimento a un tipo di struttura definito altrove. In questo caso, struct-declaration-list non può essere ripetuto finché la definizione è visibile. Le dichiarazioni di puntatori a strutture e a typedef per i tipi di strutture possono utilizzare il tag della struttura prima che il tipo di struttura venga definito. Tuttavia, la definizione della struttura deve essere rilevata prima di qualsiasi effettivo utilizzo della dimensione dei campi. Questo uso è una definizione incompleta del tipo e del tag di tipo. Affinché questa definizione venga completata, è necessario che una definizione di tipo sia presente più avanti nello stesso ambito.

Specifica struct-declaration-list i tipi e i nomi dei membri della struttura. Un struct-declaration-list argomento contiene una o più dichiarazioni di campo di bit o variabili.

Ogni variabile dichiarata in struct-declaration-list è definita come membro del tipo di struttura. Le dichiarazioni di variabili all'interno struct-declaration-list hanno lo stesso formato di altre dichiarazioni di variabili descritte in questa sezione, ad eccezione del fatto che le dichiarazioni non possono contenere identificatori di classe di archiviazione o inizializzatori. I membri della struttura possono avere qualsiasi tipo di variabile tranne il tipo void, un tipo incompleto o un tipo di funzione.

Non è possibile dichiarare che un membro abbia il tipo della struttura in cui viene visualizzata. Tuttavia, un membro può essere dichiarato come puntatore al tipo di struttura in cui è presente purché il tipo di struttura disponga di un tag. Consente di creare elenchi collegati di strutture.

Le strutture seguono lo stesso ambito di altri identificatori. Gli identificatori di struttura devono essere distinti da altri tag di struttura, unione ed enumerazione con la stessa visibilità.

Ognuno struct-declaration di essi struct-declaration-list deve essere univoco all'interno dell'elenco. Tuttavia, i nomi degli identificatori in un struct-declaration-list non devono essere distinti dai nomi delle variabili normali o dagli identificatori in altri elenchi di dichiarazioni di struttura.

Le strutture annidate sono accessibili come se fossero state dichiarate a livello di ambito file. Ad esempio, data la seguente dichiarazione:

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

queste dichiarazioni sono entrambe valide:

struct a var3;
struct b var4;

Esempio

In questi esempi vengono illustrate le dichiarazioni di strutture:

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

La struttura employee dispone di tre membri: name, id e class. Il name membro è una matrice di 20 elementi e idclass sono membri semplici rispettivamente con int e long di tipo . L'identificatore employee è l'identificatore di struttura.

struct employee student, faculty, staff;

In questo esempio vengono definiti tre variabili di struttura: student, faculty e staff. Ogni struttura presenta lo stesso elenco di tre membri. I membri vengono dichiarati per avere il tipo di struttura employee, definito nell'esempio precedente.

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

La complex struttura ha due membri con float tipo x e y. Il tipo di struttura non presenta tag ed è pertanto senza nome o anonimo.

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

I primi due membri della struttura sono una char variabile e un puntatore a un float valore. Il terzo membro, next, viene dichiarato come un puntatore al tipo di struttura che si sta definendo (sample).

Le strutture anonime possono essere utili quando il nome del tag non è necessario, ad esempio quando una dichiarazione definisce tutte le istanze della struttura. Ad esempio:

struct
{
    int x;
    int y;
} mystruct;

Le strutture incorporate sono spesso anonime.

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

Specifico di Microsoft

Il compilatore consente l'utilizzo di una matrice senza dimensione o di dimensione pari a zero come ultimo membro di una struttura. È utile se le dimensioni di una matrice costante differiscono quando vengono usate in varie situazioni. La dichiarazione di una struttura è simile alla seguente:

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

Le matrici senza dimensione possono apparire solo come ultimo membro di una struttura. Le strutture contenenti le dichiarazioni di matrice senza dimensione possono essere annidate in altre strutture purché nelle strutture di inclusione non siano dichiarati altri membri. Le matrici di tali strutture non sono consentite. L'operatore sizeof, applicato a una variabile di questo tipo o al tipo stesso, presuppone il valore 0 per la dimensione della matrice.

Le dichiarazioni di struttura possono essere specificate anche senza un dichiaratore quando sono membri di un'altra struttura o unione. I nomi dei campi vengono promossi alla struttura di inclusione. Ad esempio, una struttura senza nome avrà il seguente aspetto:

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 */

Per altre informazioni sui riferimenti alla struttura, vedere Struttura e membri dell'unione.

END Microsoft Specific

Vedi anche

Dichiaratori e dichiarazioni di variabili