Sollten Strukturdefinitionen in die Datei .h oder .c aufgenommen werden?

Ich habe sowohl vollständige Definitionen von structs in Kopfzeilen als auch nur Deklarationen gesehen - hat eine Methode einen Vorteil gegenüber der anderen?

Wenn es einen Unterschied macht, schreibe ich normalerweise eine Struktur wie diese in die .h

typedef struct s s_t;

Bearbeiten

Um klar zu sein, sind die Optionen Deklaration in der Header-Datei und Definition in der Klasse oder sowohl Deklaration als auch Definition in der Header-Datei. Beide sollten zu der gleichen Benutzerfreundlichkeit führen, auch wenn eine durch Verknüpfung erfolgt, nicht wahr?

Ich sehe viele fast Duplikate, zB hier aber keine genauen Übereinstimmungen. Bitte korrigieren Sie mich, wenn ich diesbezüglich falsch liege.

Private Strukturen für diese Datei sollten in der .c-Datei enthalten sein, mit einer Deklaration in der .h-Datei, wenn sie von Funktionen in der .h-Datei verwendet werden.

Öffentliche Strukturen sollten in die .h-Datei aufgenommen werden.

Beide sollten zu der gleichen Benutzerfreundlichkeit führen, auch wenn eine durch Verknüpfung erfolgt, nicht wahr?

Nein, nicht, wenn Sie andere .c-Dateien mit demselben Header berücksichtigen. Wenn die Definition der Struktur für den Compiler nicht sichtbar ist, können die Details dieser Definition nicht verwendet werden. Eine Deklaration ohne Definition (z. B. nur struct s;) führt dazu, dass der Compiler fehlschlägt, wenn etwas versucht, nach innen zu schauen struct s, während er z. B. kompiliert werden kann struct s *foo;(sofern dies foonicht später dereferenziert wird).

Vergleichen Sie diese Versionen von api.hund 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;          |
                                      | }                               |
                                      +---------------------------------+

Dieser Client der API funktioniert mit beiden Versionen:

#include "api.h"

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

Dieser stöbert in den Implementierungsdetails herum:

#include "api.h"

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

Dies funktioniert mit der Version "Definition in Header", jedoch nicht mit der Version "Definition in Implementierung", da der Compiler im letzteren Fall keine Sichtbarkeit des Layouts der Struktur hat:

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

Die Version "Definition in Implementierung" schützt also vor versehentlichem oder absichtlichem Missbrauch privater Implementierungsdetails.

Wenn die Struktur von anderen Kompilierungseinheiten (.c-Dateien) verwendet werden soll, platzieren Sie sie in der Header-Datei, damit Sie diese Header-Datei überall dort einfügen können, wo sie benötigt wird.

Wenn die Struktur nur in einer Kompilierungseinheit (.c-Datei) verwendet wird, platzieren Sie sie in dieser .c-Datei.

Der Punkt ist, dass Sie durch Platzieren in einer Header-Datei die Struktur (oder eine andere Definition) aus mehreren Quelldateien verwenden können, indem Sie einfach diese Header-Datei einschließen.

Aber wenn Sie sicher sind, dass es nur aus einer Quelldatei verwendet wird, macht es wirklich keinen Unterschied.

Ich habe sie in die C-Datei eingefügt, um sie objektorientierter zu gestalten. Siehe diesen Artikel .

Im Allgemeinen denke ich nicht, dass es einen großen Unterschied macht, ob Sie sie in den Header oder in die Quelldateien einfügen. Wenn Sie jedoch von mehreren Quelldateien aus auf die Mitglieder einer Struktur zugreifen müssen, ist es einfacher, die Struktur in eine Header-Datei einzufügen und sie aus anderen Dateien aufzunehmen, in denen die Struktur benötigt wird.