Was soll in eine .h-Datei gehen?

Wenn Sie Ihren Code in mehrere Dateien aufteilen, was genau sollte in eine .h-Datei und was in eine .cpp-Datei passen?

Header-Dateien ( .h) sollen die Informationen bereitstellen, die in mehreren Dateien benötigt werden. Dinge wie Klassendeklarationen, Funktionsprototypen und Aufzählungen werden normalerweise in Header-Dateien gespeichert. Mit einem Wort "Definitionen".

Codedateien ( .cpp) sollen die Implementierungsinformationen bereitstellen, die nur in einer Datei bekannt sein müssen. Im Allgemeinen gehören Funktionskörper und interne Variablen, auf die andere Module niemals zugreifen sollten / werden, zu den .cppDateien. Mit einem Wort "Implementierungen".

Die einfachste Frage, die Sie sich stellen müssen, um festzustellen, was wohin gehört, lautet: "Wenn ich dies ändere, muss ich dann den Code in anderen Dateien ändern, damit die Dinge wieder kompiliert werden?" Wenn die Antwort "Ja" lautet, gehört sie wahrscheinlich in die Header-Datei. Wenn die Antwort "Nein" lautet, gehört sie wahrscheinlich in die Codedatei.

Tatsache ist, dass dies in C ++ etwas komplizierter ist als die C-Header- / Quellorganisation.

Was sieht der Compiler?

Der Compiler sieht eine große Quelldatei (.cpp), deren Header ordnungsgemäß enthalten sind. Die Quelldatei ist die Kompilierungseinheit, die in eine Objektdatei kompiliert wird.

Warum sind Header notwendig?

Weil eine Kompilierungseinheit möglicherweise Informationen über eine Implementierung in einer anderen Kompilierungseinheit benötigt. So kann man beispielsweise die Implementierung einer Funktion in eine Quelle schreiben und die Deklaration dieser Funktion in eine andere Quelle schreiben, die sie verwenden muss.

In diesem Fall gibt es zwei Kopien derselben Informationen. Welches ist böse ...

Die Lösung besteht darin, einige Details zu teilen. Während die Implementierung in der Quelle verbleiben sollte, muss möglicherweise die Deklaration gemeinsamer Symbole wie Funktionen oder die Definition von Strukturen, Klassen, Aufzählungen usw. gemeinsam genutzt werden.

Überschriften werden verwendet, um diese freigegebenen Details zu platzieren.

Verschieben Sie in den Header die Deklarationen darüber, was von mehreren Quellen gemeinsam genutzt werden muss

Nichts mehr?

In C ++ gibt es einige andere Dinge, die in den Header eingefügt werden könnten, da sie ebenfalls gemeinsam genutzt werden müssen:

• Inline-Code
• Vorlagen
• Konstanten (normalerweise diejenigen, die Sie in Schaltern verwenden möchten ...)

Gehen Sie in den Header ALLES, was freigegeben werden muss, einschließlich freigegebener Implementierungen

Bedeutet das dann, dass sich Quellen in den Headern befinden könnten?

Ja. Tatsächlich gibt es viele verschiedene Dinge, die sich in einem "Header" befinden könnten (dh zwischen Quellen geteilt werden).

• Erklärungen weiterleiten
• Deklarationen / Definition von Funktionen / Strukturen / Klassen / Vorlagen
• Implementierung von Inline- und Vorlagencode

Es wird kompliziert und in einigen Fällen (zirkuläre Abhängigkeiten zwischen Symbolen) unmöglich, es in einem Header zu halten.

Überschriften können in drei Teile unterteilt werden

Dies bedeutet, dass Sie im Extremfall Folgendes haben könnten:

• ein Forward-Deklarationsheader
• ein Deklarations- / Definitionsheader
• ein Implementierungsheader
• eine Implementierungsquelle

Stellen wir uns vor, wir haben ein MyObject mit Vorlagen. Wir könnten haben:

// - - - - MyObject_forward.hpp - - - - 
// This header is included by the code which need to know MyObject
// does exist, but nothing more.
template<typename T>
class MyObject ;

.

// - - - - MyObject_declaration.hpp - - - - 
// This header is included by the code which need to know how
// MyObject is defined, but nothing more.
#include <MyObject_forward.hpp>

template<typename T>
class MyObject
{
   public :
      MyObject() ;
   // Etc.
} ;

void doSomething() ;

.

// - - - - MyObject_implementation.hpp - - - - 
// This header is included by the code which need to see
// the implementation of the methods/functions of MyObject,
// but nothing more.
#include <MyObject_declaration.hpp>

template<typename T>
MyObject<T>::MyObject()
{
   doSomething() ;
}

// etc.

.

// - - - - MyObject_source.cpp - - - - 
// This source will have implementation that does not need to
// be shared, which, for templated code, usually means nothing...
#include <MyObject_implementation.hpp>

void doSomething()
{
   // etc.
} ;

// etc.

Beeindruckend!

Im "wirklichen Leben" ist es normalerweise weniger kompliziert. Der meiste Code hat nur eine einfache Header- / Quellorganisation mit etwas Inline-Code in der Quelle.

In anderen Fällen (Vorlagenobjekte, die sich kennen) musste ich für jedes Objekt separate Deklarations- und Implementierungsheader haben, wobei eine leere Quelle diese Header enthielt, damit ich einige Kompilierungsfehler erkennen konnte.

Ein weiterer Grund für die Aufteilung von Headern in separate Header könnte darin bestehen, die Kompilierung zu beschleunigen, die Anzahl der analysierten Symbole auf das erforderliche Maß zu beschränken und eine unnötige Neukompilierung einer Quelle zu vermeiden, die sich nur um die Vorwärtsdeklaration kümmert, wenn sich eine Implementierung einer Inline-Methode ändert.

Fazit

Sie sollten Ihre Code-Organisation so einfach wie möglich und so modular wie möglich gestalten. Fügen Sie so viel wie möglich in die Quelldatei ein. Stellen Sie in Headern nur fest, was freigegeben werden muss.

Aber an dem Tag, an dem Sie kreisförmige Abhängigkeiten zwischen Vorlagenobjekten haben, wundern Sie sich nicht, wenn Ihre Codeorganisation etwas "interessanter" wird als die einfache Header- / Quellorganisation ...

^ _ ^

Zusätzlich zu allen anderen Antworten werde ich Ihnen sagen, was Sie NICHT in eine Header-Datei einfügen: Die
usingDeklaration (das häufigste Wesen using namespace std;) sollte nicht in einer Header-Datei erscheinen, da sie den Namespace der Quelldatei verschmutzt, in der sie enthalten ist .

Was zu nichts kompiliert wird (kein binärer Footprint), wird in die Header-Datei aufgenommen.

Variablen werden nicht zu nichts kompiliert, Typdeklarationen jedoch (weil sie nur beschreiben, wie sich Variablen verhalten).

Funktionen nicht, aber Inline-Funktionen (oder Makros), weil sie nur dort Code erzeugen, wo sie aufgerufen werden.

Vorlagen sind kein Code, sondern nur ein Rezept zum Erstellen von Code. so gehen sie auch in h-Dateien.

Im Allgemeinen fügen Sie Deklarationen in die Header-Datei und Definitionen in die Implementierungsdatei (.cpp) ein. Eine Ausnahme bilden Vorlagen, bei denen die Definition auch im Header enthalten sein muss.

Diese und ähnliche Fragen wurden häufig in SO gestellt - siehe Warum haben Header- und CPP-Dateien in C ++? und C ++ - Header-Dateien, z. B. Codetrennung .

Ihre Klassen- und Funktionsdeklarationen sowie die Dokumentation und die Definitionen für Inline-Funktionen / Methoden (obwohl einige es vorziehen, sie in separaten INL-Dateien abzulegen).

Hauptsächlich Header-Dateien enthalten Klassenskelett oder Deklaration (ändert sich nicht häufig)

und cpp-Datei enthält Klassenimplementierung (Änderungen häufig).

Die Header-Datei (.h) sollte für Deklarationen von Klassen, Strukturen und deren Methoden, Prototypen usw. sein. Die Implementierung dieser Objekte erfolgt in cpp.

in .h

    class Foo {
    int j;

    Foo();
    Foo(int)
    void DoSomething();
}

Ich würde erwarten zu sehen:

• Erklärungen
• Bemerkungen
• Definitionen inline markiert
• Vorlagen

Die wirkliche Antwort ist jedoch, was man nicht eingeben sollte:

• Definitionen (kann dazu führen, dass Dinge mehrfach definiert werden)
• Die Verwendung von Deklarationen / Anweisungen (zwingt sie jedem auf, einschließlich Ihrer Kopfzeile, kann zu Namenskonflikten führen.)

Der Header Definiert etwas, sagt aber nichts über die Implementierung aus. (Ausgenommen Vorlagen in diesem "Metafore".

Nachdem dies gesagt wurde, müssen Sie "Definitionen" in Untergruppen unterteilen. In diesem Fall gibt es zwei Arten von Definitionen.

• Sie definieren das "Layout" Ihrer Struktur und sagen nur so viel, wie von den umgebenden Nutzungsgruppen benötigt wird.
• Die Definitionen einer Variablen, Funktion und Klasse.

Jetzt spreche ich natürlich über die erste Untergruppe.

Der Header dient dazu, das Layout Ihrer Struktur zu definieren, damit der Rest der Software die Implementierung verwenden kann. Vielleicht möchten Sie es als "Abstraktion" Ihrer Implementierung sehen, was vage gesagt wird, aber ich denke, es passt in diesem Fall ganz gut.

Wie bereits in früheren Postern erwähnt, haben Sie private und öffentliche Nutzungsbereiche und deren Überschriften deklariert. Dazu gehören auch private und öffentliche Variablen. Nun, ich möchte hier nicht auf das Design des Codes eingehen, aber Sie möchten vielleicht überlegen, was Sie in Ihre Header einfügen, da dies die Ebene zwischen dem Endbenutzer und der Implementierung ist.

• Header-Dateien - sollten sich während der Entwicklung nicht zu oft ändern -> Sie sollten überlegen und sie sofort schreiben (im Idealfall)
• Quelldateien - Änderungen während der Implementierung

Header (.h)

• Makros und Includes, die für die Schnittstellen benötigt werden (so wenige wie möglich)
• Die Deklaration der Funktionen und Klassen
• Dokumentation der Schnittstelle
• Erklärung der Inline-Funktionen / Methoden, falls vorhanden
• extern zu globalen Variablen (falls vorhanden)

Körper (.cpp)

• Restliche Makros und Includes
• Fügen Sie den Header des Moduls ein
• Definition von Funktionen und Methoden
• Globale Variablen (falls vorhanden)

Als Faustregel setzen Sie den "freigegebenen" Teil des Moduls auf die .h (den Teil, den andere Module sehen müssen) und den "nicht freigegebenen" Teil auf die .cpp

PD: Ja, ich habe globale Variablen aufgenommen. Ich habe sie einige Male verwendet und es ist wichtig, sie nicht in den Headern zu definieren, sonst erhalten Sie viele Module, von denen jedes seine eigene Variable definiert.

EDIT: Geändert nach dem Kommentar von David