¿Deben ir las definiciones de estructuras en archivos .ho .c?

He visto definiciones completas de structs en encabezados y solo declaraciones. ¿Hay alguna ventaja de un método sobre el otro?

Si hace una diferencia, generalmente escribo def una estructura como esa en el .h

typedef struct s s_t;

Editar

Para ser claros, las opciones son declaración en el archivo de encabezado y definición en la clase, o tanto declaración como definición en el archivo de encabezado. Ambos deberían resultar en la misma usabilidad, incluso si uno es por enlace, ¿no es así?

Veo muchos casi duplicados, por ejemplo, aquí, pero sin coincidencias exactas. Por favor corríjame si me equivoco en este sentido.

Las estructuras privadas para ese archivo deben ir en el archivo .c, con una declaración en el archivo .h si son utilizadas por alguna función en .h.

Las estructuras públicas deben ir en el archivo .h.

Ambos deberían resultar en la misma usabilidad, incluso si uno es por enlace, ¿no es así?

No, no cuando considera otros archivos .c que incluyen el mismo encabezado. Si la definición de la estructura no es visible para el compilador, los detalles de esa definición no se pueden utilizar. Una declaración sin una definición (por ejemplo, simplemente struct s;) hace que el compilador falle si algo intenta mirar dentro struct s, mientras que aún le permite, por ejemplo, compilar struct s *foo;(siempre que foono se desreferencia más tarde).

Compare estas versiones de api.hy api.c:

Definition in header:                 Definition in implementation:
+---------------------------------+   +---------------------------------+
| struct s {                      |   | struct s;                       |
|     int internal;               |   |                                 |
|     int other_stuff;            |   | extern void                     |
| };                              |   | api_func(struct s *foo, int x); |
|                                 |   +---------------------------------+
| extern void                     |   +---------------------------------+
| api_func(struct s *foo, int x); |   | #include "api.h"                |
+---------------------------------+   |                                 |
+---------------------------------+   | struct s {                      |
| #include "api.h"                |   |     int internal;               |
|                                 |   |     int other_stuff;            |
| void                            |   | };                              |
| api_func(struct s *foo, int x)  |   |                                 |
| {                               |   | void                            |
|     foo->internal = x;          |   | api_func(struct s *foo, int x)  |
| }                               |   | {                               |
+---------------------------------+   |     foo->internal = x;          |
                                      | }                               |
                                      +---------------------------------+

Este cliente de la API funciona con cualquiera de las versiones:

#include "api.h"

void good(struct s *foo)
{
    api_func(foo, 123);
}

Este hurga en los detalles de implementación:

#include "api.h"

void bad(struct s *foo)
{
    foo->internal = 123;
}

que funcionará con la versión "definición en encabezado", pero no con la versión "definición en implementación", ya que en el último caso el compilador no tiene visibilidad del diseño de la estructura:

$ gcc -Wall -c bad.c
bad.c: In function 'bad':
bad.c:5: error: dereferencing pointer to incomplete type
$

Por lo tanto, la versión de "definición en implementación" protege contra el uso indebido accidental o deliberado de detalles de implementación privados.

Si la estructura va a ser utilizada por otras unidades de compilación (archivos .c), colóquela en el archivo de encabezado para que pueda incluir ese archivo de encabezado donde sea necesario.

Si la estructura solo se usa en una unidad de compilación (archivo .c), colóquela en ese archivo .c.

El punto es que colocarlo en un archivo de encabezado le permite usar la estructura (o cualquier otra definición) de varios archivos de origen, con solo incluir ese archivo de encabezado.

Pero si está seguro de que solo se usará desde un archivo fuente, entonces realmente no hace ninguna diferencia.

Los puse en el archivo C para hacerlo más orientado a objetos, consulte este artículo .

Generalmente, no creo que haya una gran diferencia si los coloca en el encabezado o en los archivos fuente. Sin embargo, si necesita acceder a los miembros de una estructura desde varios archivos de origen, es más fácil colocar la estructura en un archivo de encabezado e incluirlo desde cualquier otro archivo donde se necesite la estructura.