Declarações de estrutura

Uma "declaração de estrutura" nomeia um tipo e especifica uma sequência de valores variáveis (chamados "membros" ou "campos" da estrutura) que podem ter diferentes tipos. Um identificador opcional, chamado de "tag", dá 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 línguas.

Sintaxe

struct-or-union-specifier:
  struct-or-union identifier _{optar por}{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 por}
  type-qualifier specifier-qualifier-list _{optar por}

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

struct-declarator:
 declarator
  type-specifier declarator _{optar por}: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 tag previamente definida identifier (tag) pode ser usada para se referir a um tipo de estrutura definido em outro lugar. Neste caso, não pode ser repetido, struct-declaration-list desde que a definição seja 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 tag type. Para que esta definição seja completada, uma definição de tipo deve aparecer posteriormente no mesmo âmbito.

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

Cada variável declarada em struct-declaration-list é definida como um membro do tipo de estrutura. As declarações de variáveis dentro struct-declaration-list têm a mesma forma que outras declarações de variáveis 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 como tendo o tipo da estrutura em que aparece. No entanto, um membro pode ser declarado como um ponteiro para o tipo de estrutura em que aparece, desde que o tipo de estrutura tenha uma tag. 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 tags de estrutura, união e enumeração com a mesma visibilidade.

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

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

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

Estas declarações são ambas 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 é composta por três membros: name, id, e class. O name membro é uma matriz de 20 elementos, e idclass são membros simples com int e long tipo, respectivamente. O identificador employee é o identificador da estrutura.

struct employee student, faculty, staff;

Este exemplo define três variáveis de estrutura: student, faculty, e staff. Cada estrutura tem a mesma lista de três membros. Os membros são declarados como tendo 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 tag 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, next, é declarado como um ponteiro para o tipo de estrutura que está sendo definido (sample).

Estruturas anônimas podem ser úteis quando o nome da tag 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 incorporadas são frequentemente anónimas.

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

Específico da Microsoft

O compilador permite uma matriz sem tamanho ou de tamanho zero como o último membro de uma estrutura. É útil se o tamanho de uma matriz constante for diferente quando usado em várias situações. A declaração de tal estrutura é assim:

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

Matrizes sem tamanho podem aparecer apenas como o último membro de uma estrutura. As estruturas que contêm declarações de matriz não dimensionadas podem ser aninhadas em outras estruturas, desde que nenhum membro adicional seja declarado em nenhuma estrutura de encerramento. Matrizes de tais 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 declarante quando são membros de outra estrutura ou união. Os nomes dos campos são promovidos para a estrutura anexa. 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.

END Específico da Microsoft

Ver também

Declaradores e declarações variáveis