Le definizioni della struttura devono essere contenute nel file .h o .c?

Ho visto sia le definizioni complete di structs nelle intestazioni che solo le dichiarazioni: c'è qualche vantaggio in un metodo rispetto all'altro?

Se fa la differenza, di solito digito una struttura in questo modo nel file .h

typedef struct s s_t;

modificare

Per essere chiari, le opzioni sono la dichiarazione nel file di intestazione e la definizione nella classe, o sia la dichiarazione che la definizione nel file di intestazione. Entrambi dovrebbero portare alla stessa usabilità, anche se uno è per collegamento, no?

Vedo molti quasi duplicati, ad esempio qui ma nessuna corrispondenza esatta. Per favore correggimi se sbaglio a questo proposito.

Le strutture private per quel file dovrebbero andare nel file .c, con una dichiarazione nel file .h se vengono utilizzate da qualsiasi funzione nel .h.

Le strutture pubbliche dovrebbero andare nel file .h.

Entrambi dovrebbero portare alla stessa usabilità, anche se uno è per collegamento, no?

No, non quando si considerano altri file .c che includono la stessa intestazione. Se la definizione della struttura non è visibile al compilatore, i dettagli di quella definizione non possono essere utilizzati. Una dichiarazione senza una definizione (ad esempio solo struct s;) fa sì che il compilatore fallisca se qualcosa cerca di guardare all'interno struct s, pur permettendogli di ad esempio di compilare struct s *foo;(purché foonon venga successivamente dereferenziato).

Confronta queste versioni di api.he 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;          |
                                      | }                               |
                                      +---------------------------------+

Questo client dell'API funziona con entrambe le versioni:

#include "api.h"

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

Questo fa un giro nei dettagli di implementazione:

#include "api.h"

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

che funzionerà con la versione "definizione in intestazione", ma non con la versione "definizione in implementazione", in quanto in quest'ultimo caso il compilatore non ha visibilità del layout della struttura:

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

Quindi, la versione "definizione nell'implementazione" protegge dall'uso improprio accidentale o intenzionale dei dettagli dell'implementazione privata.

Se la struttura deve essere utilizzata da altre unità di compilazione (file .c), inserirla nel file di intestazione in modo da poter includere tale file di intestazione ovunque sia necessario.

Se la struttura viene utilizzata solo in un'unità di compilazione (file .c), la si inserisce in quel file .c.

Il punto è che posizionarlo in un file di intestazione ti consente di utilizzare la struttura (o qualsiasi altra definizione) da più file di origine, semplicemente includendo quel file di intestazione.

Ma se sei sicuro che verrà utilizzato solo da un file sorgente, allora non fa davvero alcuna differenza.

Li ho inseriti nel file C per renderlo più orientato agli oggetti, vedi questo articolo .

In generale, non penso che faccia una grande differenza se li metti nell'intestazione o nei file sorgente. Tuttavia, se è necessario accedere ai membri di una struttura da più file di origine, è più semplice inserire la struttura in un file di intestazione e includerla da qualsiasi altro file in cui è necessaria la struttura.