Les définitions de structure doivent-elles aller dans un fichier .h ou .c?

J'ai vu à la fois des définitions complètes de structs dans les en-têtes et juste des déclarations - y a-t-il un avantage à une méthode par rapport à l'autre?

Si cela fait une différence, je tape généralement une structure comme celle-ci dans le .h

typedef struct s s_t;

Éditer

Pour être clair, les options sont la déclaration dans le fichier d'en-tête et la définition dans la classe, ou à la fois la déclaration et la définition dans le fichier d'en-tête. Les deux devraient aboutir à la même utilisabilité, même si on est par liaison, n'est-ce pas?

Je vois de nombreux presque doublons, par exemple ici mais pas de correspondances exactes. Veuillez me corriger si je me trompe à cet égard.

Les structures privées de ce fichier doivent aller dans le fichier .c, avec une déclaration dans le fichier .h si elles sont utilisées par des fonctions du fichier .h.

Les structures publiques doivent aller dans le fichier .h.

Les deux devraient aboutir à la même utilisabilité, même si on est par liaison, n'est-ce pas?

Non, pas lorsque vous considérez d'autres fichiers .c incluant le même en-tête. Si la définition de la structure n'est pas visible par le compilateur, les détails de cette définition ne peuvent pas être utilisés. Une déclaration sans définition (par exemple juste struct s;) fait échouer le compilateur si quelque chose tente de regarder à l'intérieur struct s, tout en lui permettant par exemple de compiler struct s *foo;(tant quefoo n'est pas déréférencé ultérieurement).

Comparez ces versions de api.het 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;          |
                                      | }                               |
                                      +---------------------------------+

Ce client de l'API fonctionne avec les deux versions:

#include "api.h"

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

Celui-ci fouille dans les détails de l'implémentation:

#include "api.h"

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

qui fonctionnera avec la version "définition en entête", mais pas avec la version "définition en implémentation", car dans ce dernier cas le compilateur n'a pas de visibilité sur la mise en page de la structure:

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

Ainsi, la version «définition dans l'implémentation» protège contre l'utilisation abusive accidentelle ou délibérée des détails d'implémentation privée.

Si la structure doit être utilisée par d'autres unités de compilation (fichiers .c), placez-la dans le fichier d'en-tête afin de pouvoir inclure ce fichier d'en-tête partout où il est nécessaire.

Si la structure n'est utilisée que dans une seule unité de compilation (fichier .c), vous la placez dans ce fichier .c.

Le fait est que le placer dans un fichier d'en-tête vous permet d'utiliser la structure (ou toute autre définition) à partir de plusieurs fichiers source, simplement en incluant ce fichier d'en-tête.

Mais si vous êtes sûr qu'il ne sera utilisé qu'à partir d'un seul fichier source, cela ne fait vraiment aucune différence.

Je les mets dans le fichier C pour le rendre plus orienté objet, voir cet article .

En général, je ne pense pas que cela fasse une énorme différence si vous les mettez dans l'en-tête ou dans les fichiers source. Toutefois, si vous avez besoin d'accéder aux membres d'une structure à partir de plusieurs fichiers source, il est plus facile de placer la structure dans un fichier d'en-tête et de l'inclure à partir de tout autre fichier où la structure est nécessaire.