C: nombre de estructura typedef {…}; VS typedef struct {…} name;

Solución:

Aquí están sucediendo varias cosas. Primero, como han dicho otros, la queja del compilador sobre el tipo desconocido puede deberse a que necesita definir los tipos antes de usarlos. Sin embargo, lo más importante es comprender la sintaxis de 3 cosas: (1) definición de estructura, (2) declaración de estructura y (3) typedef.

Al definir una estructura, la estructura puede tener un nombre o no (si no tiene nombre, entonces debe usarse inmediatamente (explicará lo que esto significa más adelante)).

struct Name {
   ...
};

Esto define un tipo llamado “nombre de estructura” que luego se puede utilizar para declarar una variable de estructura:

struct Name myNameStruct;

Esto declara una variable llamada myNameStruct que es una estructura de tipo struct Name.

También puede definir una estructura y declarar una variable de estructura al mismo tiempo:

struct Name {
   ...
} myNameStruct;

Como antes, esto declara una variable llamada myNameStruct que es una estructura de tipo struct Name … Pero lo hace al mismo tiempo que define el tipo struct Name.
El tipo se puede usar nuevamente para declarar otra variable:

struct Name myOtherNameStruct;

Ahora typedef es solo una forma de alias un tipo con un nombre específico:

typedef OldTypeName NewTypeName;

Dado el typedef anterior, cada vez que use NewTypeName es lo mismo que usar OldTypeName. En el lenguaje de programación C, esto es particularmente útil con estructuras, porque le da la capacidad de omitir la palabra “estructura” al declarar variables de ese tipo. y tratar el nombre de la estructura simplemente como un tipo en sí mismo (como lo hacemos en C ++). A continuación, se muestra un ejemplo que primero define la estructura y luego define la estructura:

struct Name {
   ...
};

typedef struct Name Name_t;

En el OldTypeName anterior es struct Name y NewTypeName es Name_t. Entonces, ahora, para declarar una variable de tipo struct Name, en lugar de escribir:

struct Name myNameStruct;

Puedo escribir simple:

Name_t myNameStruct;

NOTA TAMBIÉN, el typedef PUEDE COMBINARSE con la definición de estructura, y esto es lo que está haciendo en su código:

typedef struct {
   ...
} Name_t;

Esto también se puede hacer al nombrar la estructura, pero esto es superfluo:

typedef struct Name {
   ...
} Name_t;

BUENA NOTA: En la sintaxis anterior, dado que ha comenzado con “typedef”, toda la declaración es una typedef declaración, en la que OldTypeName pasa a ser una definición de estructura. Por lo tanto, el compilador interpreta el nombre que viene después la llave derecha} como NewTypeName … es NO el nombre de la variable (como estaría en la sintaxis sin typedef, en cuyo caso estaría definiendo la estructura y declarando una variable de estructura al mismo tiempo).

Además, si indica typedef, pero deja el Name_t al final, entonces ha creado efectivamente una declaración typedef INCOMPLETA, porque el compilador considera todo dentro de “struct Name { ... }“como OldTypeName, y no está proporcionando un NewTypeName para typedef. Es por eso que el compilador no está satisfecho con el código tal como lo ha escrito (aunque los mensajes del compilador son bastante crípticos porque no está muy seguro de qué hizo mal).

Ahora, como señalé anteriormente, si no nombra el tipo de estructura en el momento en que lo define, debe usarlo inmediatamente para declarar una variable:

struct {
   ...
} myNameStruct;  // declares myNameStruct as a variable with this struct
                 // definition, but the definition cannot be re-used.

O puede usar un tipo de estructura sin nombre en un typedef:

typedef struct {
   ...
} Name_t;

Esta sintaxis final es lo que realmente hizo cuando escribió:

typedef struct{
   char firstName[56];
   char lastName[56];
} Author;

Y el compilador estaba feliz. HTH.

Con respecto al comentario / pregunta sobre el sufijo _t:

El sufijo _t es una convención, para indicar a las personas que leen el código que el nombre simbólico con _t es un nombre de tipo (a diferencia de un nombre de variable). El compilador no analiza ni tiene conocimiento de _t.

Las bibliotecas estándar C89, y particularmente C99, definieron muchos tipos Y ELEGIRON USAR _t para los nombres de esos tipos. Por ejemplo, el estándar C89 define wchar_t, off_t, ptrdiff_t. El estándar C99 define muchos tipos adicionales, como uintptr_t, intmax_t, int8_t, uint_least16_t, uint_fast32_t, etc. Pero _t no está reservado, ni especialmente analizado, ni el compilador lo nota, es simplemente una convención que es bueno seguir. cuando está definiendo nuevos tipos (a través de typedef) en C. En C ++, muchas personas usan la convención para comenzar los nombres de los tipos con mayúsculas, por ejemplo, MyNewType (a diferencia de la convención de C my_new_type_t). HTH

La sintaxis es de typedef es como sigue:

typedef old_type new_type

En su primer intento, definió el struct Book tipo y no Book. En otras palabras, su tipo de datos se llama struct Book y no Book.

En la segunda forma, usaste la sintaxis correcta de typedef, por lo que el compilador reconoce el tipo llamado Book.

---

---

Utiliza Nuestro Buscador