C / C ++ enthält die Reihenfolge der Header-Dateien

In welcher Reihenfolge sollten Dateien angegeben werden, dh aus welchen Gründen wird ein Header vor einem anderen eingefügt?

Gehen die Systemdateien STL und Boost beispielsweise vor oder nach den lokalen Include-Dateien?

Ich glaube nicht, dass es eine empfohlene Bestellung gibt, solange sie kompiliert wird! Was ärgerlich ist, ist, wenn einige Header erfordern, dass andere Header zuerst eingeschlossen werden ... Das ist ein Problem mit den Headern selbst, nicht mit der Reihenfolge der Includes.

Meine persönliche Präferenz ist es, von lokal zu global zu wechseln, wobei jeder Unterabschnitt in alphabetischer Reihenfolge angezeigt wird, dh:

1. h-Datei, die dieser CPP-Datei entspricht (falls zutreffend)
2. Header aus derselben Komponente,
3. Header von anderen Komponenten,
4. Systemheader.

Meine Begründung für 1. ist, dass es beweisen sollte, dass jeder Header (für den es einen CPP gibt) #includeohne Voraussetzungen d sein kann (terminus technicus: Header ist "in sich geschlossen"). Und der Rest scheint nur logisch von dort zu fließen.

Das Wichtigste ist, dass Ihre Header nicht davon abhängig sein sollten, dass zuerst andere Header eingefügt werden. Eine Möglichkeit, dies sicherzustellen, besteht darin, Ihre Header vor allen anderen Headern einzuschließen.

Insbesondere "Thinking in C ++" erwähnt dies und verweist auf Lakos '"Large Scale C ++ Software Design":

Latente Verwendungsfehler können vermieden werden, indem sichergestellt wird, dass die .h-Datei einer Komponente von selbst analysiert wird - ohne extern bereitgestellte Deklarationen oder Definitionen ... Wenn Sie die .h-Datei als allererste Zeile der .c-Datei einschließen, wird sichergestellt, dass kein kritisches Element vorhanden ist In der .h-Datei fehlen Informationen, die der physischen Schnittstelle der Komponente eigen sind (oder, falls vorhanden, Sie werden davon erfahren, sobald Sie versuchen, die .c-Datei zu kompilieren).

Das heißt, in der folgenden Reihenfolge einschließen:

1. Der Prototyp / Interface-Header für diese Implementierung (dh die .h / .hh-Datei, die dieser .cpp / .cc-Datei entspricht).
2. Andere Header aus demselben Projekt nach Bedarf.
3. Header aus anderen nicht standardmäßigen Nicht-Systembibliotheken (z. B. Qt, Eigen usw.).
4. Header aus anderen "fast Standard" -Bibliotheken (z. B. Boost)
5. Standard-C ++ - Header (z. B. iostream, funktional usw.)
6. Standard-C-Header (z. B. cstdint, dirent.h usw.)

Wenn einer der Header ein Problem mit der Aufnahme in diese Reihenfolge hat, beheben Sie ihn entweder (falls vorhanden) oder verwenden Sie ihn nicht. Boykottieren Sie Bibliotheken, die keine sauberen Header schreiben.

Googles C ++ - Styleguide argumentiert fast umgekehrt, ohne wirklich zu rechtfertigen. Ich persönlich tendiere dazu, den Lakos-Ansatz zu bevorzugen.

Ich folge zwei einfachen Regeln, die die überwiegende Mehrheit der Probleme vermeiden:

1. Alle Header (und in der Tat alle Quelldateien) sollten enthalten, was sie benötigen. Sie sollten sich nicht auf ihre Benutzer verlassen, einschließlich der Dinge.
2. Als Ergänzung sollten alle Header Schutzvorrichtungen enthalten, damit sie durch die zu ehrgeizige Anwendung der obigen Regel 1 nicht mehrmals eingeschlossen werden.

Ich folge auch den Richtlinien von:

1. Fügen Sie zuerst Systemheader (stdio.h usw.) mit einer Trennlinie ein.
2. Gruppieren Sie sie logisch.

Mit anderen Worten:

#include <stdio.h>
#include <string.h>

#include "btree.h"
#include "collect_hash.h"
#include "collect_arraylist.h"
#include "globals.h"

Als Richtlinien ist das allerdings eine subjektive Sache. Auf der anderen Seite setze ich die Regeln strikt durch, bis ich Wrapper-Header-Dateien mit Include-Guards und gruppierten Includes versorge, wenn ein widerlicher Entwickler von Drittanbietern meine Vision nicht abonniert :-)

Um meinen eigenen Ziegelstein an die Wand zu hängen.

1. Jeder Header muss autark sein, was nur getestet werden kann, wenn er mindestens einmal zuerst enthalten ist
2. Man sollte die Bedeutung eines Headers eines Drittanbieters nicht fälschlicherweise durch Einfügen von Symbolen (Makro, Typen usw.) ändern.

Also gehe ich normalerweise so:

// myproject/src/example.cpp
#include "myproject/example.h"

#include <algorithm>
#include <set>
#include <vector>

#include <3rdparty/foo.h>
#include <3rdparty/bar.h>

#include "myproject/another.h"
#include "myproject/specific/bla.h"

#include "detail/impl.h"

Jede Gruppe durch eine Leerzeile von der nächsten getrennt:

• Header, der zuerst dieser CPP-Datei entspricht (Sanity Check)
• Systemheader
• Header von Drittanbietern, sortiert nach Abhängigkeitsreihenfolge
• Projektheader
• Projekt private Header

Beachten Sie außerdem, dass sich jede Datei, abgesehen von den Systemheadern, in einem Ordner mit dem Namen ihres Namespace befindet, nur weil es einfacher ist, sie auf diese Weise aufzuspüren.

Ich empfehle:

1. Der Header für das .cc-Modul, das Sie erstellen. (Stellt sicher, dass jeder Header in Ihrem Projekt keine impliziten Abhängigkeiten von anderen Headern in Ihrem Projekt aufweist.)
2. C-Systemdateien.
3. C ++ - Systemdateien.
4. Plattform- / Betriebssystem- / andere Header-Dateien (z. B. win32, gtk, openGL).
5. Andere Header-Dateien aus Ihrem Projekt.

Und natürlich, wenn möglich, in alphabetischer Reihenfolge in jedem Abschnitt.

Verwenden Sie immer Forward-Deklarationen, um unnötige #includes in Ihren Header-Dateien zu vermeiden .

Ich bin mir ziemlich sicher, dass dies nirgendwo in der vernünftigen Welt eine empfohlene Vorgehensweise ist, aber ich mag es, System-Includes nach Dateinamenlänge zu ordnen, die lexikalisch innerhalb derselben Länge sortiert sind. Wie so:

#include <set>
#include <vector>
#include <algorithm>
#include <functional>

Ich denke, es ist eine gute Idee, eigene Header vor anderen Völkern einzufügen, um die Schande der Abhängigkeit von der Reihenfolge der Einschlüsse zu vermeiden.

Das ist nicht subjektiv. Stellen Sie sicher, dass Ihre Header nicht darauf angewiesen sind, #includein einer bestimmten Reihenfolge d zu sein. Sie können sicher sein, dass es keine Rolle spielt, in welcher Reihenfolge Sie STL- oder Boost-Header einfügen.

Fügen Sie zuerst den Header ein, der der .cpp entspricht. Mit anderen Worten, source1.cppsollte enthalten sein, source1.hbevor Sie etwas anderes einfügen . Die einzige Ausnahme, an die ich denken kann, ist die Verwendung von MSVC mit vorkompilierten Headern. In diesem Fall müssen Sie stdafx.hvor allem anderen einschließen .

Begründung: Durch das Einfügen der source1.hvorherigen Dateien wird sichergestellt, dass sie ohne Abhängigkeiten eigenständig sind. Wenn Sie source1.hzu einem späteren Zeitpunkt eine Abhängigkeit annehmen, werden Sie vom Compiler sofort gewarnt, die erforderlichen Weiterleitungsdeklarationen hinzuzufügen source1.h. Dies stellt wiederum sicher, dass Header von ihren Angehörigen in beliebiger Reihenfolge aufgenommen werden können.

Beispiel:

source1.h

class Class1 {
    Class2 c2;    // a dependency which has not been forward declared
};

source1.cpp

#include "source1.h"    // now compiler will alert you saying that Class2 is undefined
                    // so you can forward declare Class2 within source1.h
...

MSVC-Benutzer: Ich empfehle dringend, vorkompilierte Header zu verwenden. Verschieben Sie daher alle #includeAnweisungen für Standardheader (und andere Header, die sich nie ändern werden) nach stdafx.h.

Schließen Sie von der spezifischsten zur am wenigsten spezifischen ein, beginnend mit der entsprechenden .hpp für die .cpp, falls eine solche vorhanden ist. Auf diese Weise werden alle versteckten Abhängigkeiten in Header-Dateien aufgedeckt, die nicht autark sind.

Dies wird durch die Verwendung vorkompilierter Header erschwert. Eine Möglichkeit, dies zu umgehen, besteht darin, ohne den Projekt-Compiler spezifisch zu machen, einen der Projekt-Header als vorkompilierte Header-Include-Datei zu verwenden.

In der C / C ++ - Welt ist dies eine schwierige Frage, da so viele Elemente über den Standard hinausgehen.

Ich denke, die Reihenfolge der Header-Dateien ist kein ernstes Problem, solange sie kompiliert werden, wie Squelart sagte.

Meine Ideen sind: Wenn in all diesen Headern kein Symbolkonflikt besteht, ist jede Reihenfolge in Ordnung, und das Problem mit der Headerabhängigkeit kann später behoben werden, indem dem fehlerhaften .h Zeilen #include hinzugefügt werden.

Der eigentliche Ärger entsteht, wenn ein Header seine Aktion ändert (indem er die # if-Bedingungen überprüft), je nachdem, welche Header oben stehen.

In stddef.h in VS2005 gibt es beispielsweise Folgendes:

#ifdef  _WIN64
#define offsetof(s,m)   (size_t)( (ptrdiff_t)&(((s *)0)->m) )
#else
#define offsetof(s,m)   (size_t)&(((s *)0)->m)
#endif

Nun das Problem: Wenn ich einen benutzerdefinierten Header ("custom.h") habe, der mit vielen Compilern verwendet werden muss, einschließlich einiger älterer, die nicht offsetofin ihren Systemheadern enthalten sind, sollte ich in meinen Header schreiben:

#ifndef offsetof
#define offsetof(s,m)   (size_t)&(((s *)0)->m)
#endif

Und stellen Sie sicher, dass Sie den Benutzer #include "custom.h" nach allen System-Headern offsetofanweisen , andernfalls wird in der Zeile in stddef.h ein Makro-Neudefinitionsfehler angezeigt.

Wir beten darum, in unserer Karriere keine solchen Fälle mehr zu erleben.