Declaraciones de estructura

Una "declaración de estructura" asigna un nombre a un tipo y especifica una secuencia de valores de variable (denominados "miembros" o "campos" de la estructura) que pueden tener diferentes tipos. Un identificador opcional, denominado "etiqueta", proporciona el nombre del tipo de estructura y se puede usar en referencias posteriores al tipo de estructura. Una variable de ese tipo de estructura contiene toda la secuencia definida por ese tipo. Las estructuras de C son similares a los tipos conocidos como "registros" en otros lenguajes.

Sintaxis

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

La declaración de un tipo de estructura no reserva espacio para una estructura. Solo es una plantilla para declaraciones posteriores de variables de estructura.

Se puede usar una etiqueta (etiqueta) definida identifier previamente para hacer referencia a un tipo de estructura definido en otro lugar. En este caso, struct-declaration-list no se puede repetir siempre que la definición sea visible. Las declaraciones de punteros a estructuras y definiciones de tipo para los tipos de estructura pueden usar la etiqueta structure antes de definir el tipo de estructura. Sin embargo, la definición de la estructura debe encontrarse antes de cualquier uso real del tamaño de los campos. Este uso es una definición incompleta del tipo y la etiqueta de tipo. Para que esta definición se complete, una definición de tipo debe aparecer más adelante en el mismo ámbito.

struct-declaration-list especifica los tipos y nombres de los miembros de la estructura. Un struct-declaration-list argumento contiene una o varias declaraciones de campo de bits o variables.

Cada variable declarada en struct-declaration-list se define como miembro del tipo de estructura. Las declaraciones de variables dentro struct-declaration-list tienen el mismo formato que otras declaraciones de variable descritas en esta sección, salvo que las declaraciones no pueden contener especificadores o inicializadores de clase de almacenamiento. Los miembros de la estructura pueden tener cualquier tipo de variable, excepto el tipo void, un tipo incompleto o un tipo de función.

No se puede declarar un miembro para que tenga el tipo de la estructura en la que aparece. Sin embargo, un miembro se puede declarar como puntero al tipo de estructura en el que aparece siempre que el tipo de estructura tenga una etiqueta. Permite crear listas vinculadas de estructuras.

Las estructuras siguen el mismo ámbito que otros identificadores. Los identificadores de estructura deben ser distintos de otras etiquetas de estructura, unión y enumeración con la misma visibilidad.

Cada struct-declaration uno de los struct-declaration-list elementos debe ser único dentro de la lista. Sin embargo, los nombres de identificador de un struct-declaration-list no tienen que ser distintos de los nombres de variables normales ni de los identificadores de otras listas de declaraciones de estructura.

También se puede acceder a las estructuras anidadas como si se declararan en el nivel de ámbito de archivo. Por ejemplo, dada esta declaración:

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

estas declaraciones son legales:

struct a var3;
struct b var4;

Ejemplos

En estos ejemplos se muestran las declaraciones de estructura:

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

La employee estructura tiene tres miembros: name, idy class. El name miembro es una matriz de 20 elementos y id son class miembros simples con int y long tipo, respectivamente. El identificador employee es el identificador de estructura.

struct employee student, faculty, staff;

En este ejemplo se definen tres variables de estructura: student, facultyy staff. Cada estructura tiene la misma lista de tres miembros. Los miembros se declaran para tener el tipo employeede estructura , definido en el ejemplo anterior.

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

La complex estructura tiene dos miembros con float el tipo y yx . El tipo de estructura no tiene ninguna etiqueta y, por tanto, no tiene nombre ni anónimo.

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

Los dos primeros miembros de la estructura son una char variable y un puntero a un float valor. El tercer miembro, next, se declara como puntero al tipo de estructura que se define (sample).

Las estructuras anónimas pueden ser útiles cuando no se necesita el nombre de etiqueta, como cuando una declaración define todas las instancias de estructura. Por ejemplo:

struct
{
    int x;
    int y;
} mystruct;

Las estructuras incrustadas suelen ser anónimas.

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

Específicos de Microsoft

El compilador permite una matriz de tamaño cero o sin tamaño como el último miembro de una estructura. Es útil si el tamaño de una matriz constante difiere cuando se usa en varias situaciones. La declaración de esta estructura tiene este aspecto:

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

Las matrices sin tamaño solo pueden aparecer como el último miembro de una estructura. Las estructuras que contienen declaraciones de matriz sin tamaño se pueden anidar dentro de otras estructuras siempre y cuando no se declare ningún miembro adicional en ninguna estructura envolvente. No se permiten matrices de estas estructuras. El sizeof operador, cuando se aplica a una variable de este tipo o al propio tipo, supone 0 para el tamaño de la matriz.

Las declaraciones de estructura también se pueden especificar sin un declarador cuando son miembros de otra estructura o unión. Los nombres de campo se promueven a la estructura envolvente. Por ejemplo, una estructura sin nombre tiene el siguiente aspecto:

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 obtener más información sobre las referencias de estructura, vea Miembros de estructura y unión.

FIN Específico de Microsoft

Consulte también

Declaradores y declaraciones de variables