Declarações de estrutura

Uma "declaração de estrutura" nomeia um tipo e especifica uma sequência de valores variáveis (chamados de "membros" ou "campos" da estrutura) que podem ter tipos diferentes. Um identificador opcional, chamado de "tag", fornece o nome do tipo de estrutura e pode ser usado em referências subsequentes ao tipo de estrutura. Uma variável desse tipo de estrutura contém toda a sequência definida por esse tipo. As estruturas em C são semelhantes aos tipos conhecidos como "registros" em outras linguagens.

Sintaxe

struct-or-union-specifier:
  struct-or-union identifier _optar{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 _optar
  type-qualifier specifier-qualifier-list _optar

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

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

A declaração de um tipo de estrutura não reserva espaço para uma estrutura. É apenas um modelo para declarações posteriores de variáveis de estrutura.

Uma (marca) definida identifier anteriormente pode ser usada para se referir a um tipo de estrutura definido em outro lugar. Nesse caso, struct-declaration-list não pode ser repetido desde que a definição esteja visível. Declarações de ponteiros para estruturas e typedefs para tipos de estrutura podem usar a marca de estrutura antes que o tipo de estrutura seja definido. No entanto, a definição da estrutura deve ser encontrada antes de qualquer uso real do tamanho dos campos. Esse uso é uma definição incompleta do tipo e da marca de tipo. Para que essa definição seja concluída, uma definição de tipo deve aparecer posteriormente no mesmo escopo.

Especifica struct-declaration-list os tipos e nomes dos membros da estrutura. Um struct-declaration-list argumento contém uma ou mais declarações de variável ou de campo de bit.

Cada variável declarada struct-declaration-list é definida como um membro do tipo de estrutura. As declarações de variável dentro struct-declaration-list têm o mesmo formulário que outras declarações de variável discutidas nesta seção, exceto que as declarações não podem conter especificadores ou inicializadores de classe de armazenamento. Os membros da estrutura podem ter qualquer tipo de variável, exceto tipo void, um tipo incompleto ou um tipo de função.

Um membro não pode ser declarado para ter o tipo da estrutura na qual ele aparece. No entanto, um membro pode ser declarado como um ponteiro para o tipo de estrutura no qual ele aparece, desde que o tipo de estrutura tenha uma marca. Ele permite que você crie listas vinculadas de estruturas.

As estruturas seguem o mesmo escopo que outros identificadores. Os identificadores de estrutura devem ser distintos de outras marcas de estrutura, união e enumeração com a mesma visibilidade.

Cada struct-declaration um em um struct-declaration-list deve ser exclusivo dentro da lista. No entanto, os nomes de identificador em um struct-declaration-list não precisam ser distintos de nomes de variáveis comuns ou de identificadores em outras listas de declarações de estrutura.

As estruturas aninhadas também podem ser acessadas como se fossem declaradas no nível do escopo do arquivo. Por exemplo, dada esta declaração:

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

essas declarações são legais:

struct a var3;
struct b var4;

Exemplos

Estes exemplos ilustram declarações de estrutura:

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

A employee estrutura tem três membros: name, ide class. O name membro é uma matriz de 20 elementos e idclass são membros simples com int e long digitam, respectivamente. O identificador employee é o identificador da estrutura.

struct employee student, faculty, staff;

Este exemplo define três variáveis de estrutura: student, facultye staff. Cada estrutura tem a mesma lista de três membros. Os membros são declarados com o tipo employeede estrutura definido no exemplo anterior.

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

A complex estrutura tem dois membros com float tipo x e y. O tipo de estrutura não tem marca e, portanto, não tem nome ou é anônimo.

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

Os dois primeiros membros da estrutura são uma char variável e um ponteiro para um float valor. O terceiro membro é nextdeclarado como um ponteiro para o tipo de estrutura que está sendo definido (sample).

Estruturas anônimas podem ser úteis quando o nome da marca não é necessário, como quando uma declaração define todas as instâncias de estrutura. Por exemplo:

struct
{
    int x;
    int y;
} mystruct;

As estruturas inseridas geralmente são anônimas.

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

Específico da Microsoft

O compilador permite uma matriz de tamanho zero ou não dimensionada como o último membro de uma estrutura. Será útil se o tamanho de uma matriz constante for diferente quando usado em várias situações. A declaração de tal estrutura tem esta aparência:

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

Matrizes não dimensionadas só podem aparecer como o último membro de uma estrutura. Estruturas que contêm declarações de matriz não dimensionadas podem ser aninhadas dentro de outras estruturas, desde que nenhum membro adicional seja declarado em nenhuma estrutura delimitado. Matrizes dessas estruturas não são permitidas. O sizeof operador, quando aplicado a uma variável desse tipo ou ao próprio tipo, assume 0 para o tamanho da matriz.

As declarações de estrutura também podem ser especificadas sem um declarador quando são membros de outra estrutura ou união. Os nomes de campo são promovidos para a estrutura delimitada. Por exemplo, uma estrutura sem nome tem esta aparência:

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

Para obter mais informações sobre referências de estrutura, consulte Estrutura e Membros da União.

Fim da seção específica da Microsoft

Consulte também

Declaradores e declarações de variável