Freigeben über

Exemplarische Vorgehensweise: Importieren von STL-Bibliotheken als Headereinheiten

  • Artikel

In dieser exemplarischen Vorgehensweise erfahren Sie, wie Sie C++-Standardvorlagenbibliotheken (STL) als Headereinheiten in Visual Studio importieren. Einen noch schnelleren und robusteren Weg, die Standardbibliothek zu importieren, finden Sie unter Tutorial: Importieren der C++-Standardbibliothek mit Modulen.

Das Importieren eines STL-Headers als Headereinheit ist einfacher als die Verwendung vorkompilierter Headerdateien. Headereinheiten sind einfacher einzurichten und zu verwenden, sind wesentlich kleiner auf dem Datenträger, bieten ähnliche Leistungsvorteile und sind flexibler als ein gemeinsam genutzter vorkompilierter Header (PCH).

Ausführlichere Informationen darüber, was Headereinheiten sind und welche Vorteile sie bieten, finden Sie unter Was ist eine Headereinheit?. Informationen zum Kontrast von Headereinheiten mit anderen Methoden zum Importieren der Standardbibliothek finden Sie unter Vergleichen von Headereinheiten, Modulen und vorkompilierten Headern.

Voraussetzungen

Um Headereinheiten zu verwenden, verwenden Sie Visual Studio 2022 oder höher bzw. Visual Studio 2019 Version 16.11 oder höher. Die Option /std:c++20 (oder später) muss Headereinheiten verwenden.

Zwei Ansätze zum Importieren von STL-Headern als Headereinheiten

Bevor Sie einen STL-Header importieren können, muss er in eine Headereinheit kompiliert werden. Eine Headereinheit ist eine binäre Darstellung einer Headerdatei. Es ist eine .ifc-Erweiterung.

Sie sollten eine statische Bibliothek erstellen, die die erstellten Headereinheiten für die STL-Header enthält, die Sie verwenden möchten. Dann referenzieren Sie diese Bibliothek und import ihre Headereinheiten. Dieser Ansatz kann zu schnelleren Builds und besserer Wiederverwendung führen. Um diesen Ansatz auszuprobieren, lesen Sie bitte Ansatz 1: Erstellen einer statischen Bibliothek von STL-Bibliothekskopfeinheiten.

Ein anderer Ansatz besteht darin, Visual Studio nach den STL-Headern suchen zu lassen, die Sie mit #include in Ihr Projekt einbinden, sie in Headereinheiten zu kompilieren und diese mit import Header einzubinden, anstatt sie mit #include einzubinden. Dieser Ansatz ist nützlich, wenn Sie über eine große Codebasis verfügen, da Sie ihren Quellcode nicht ändern müssen. Dieser Ansatz ist weniger flexibel als der Ansatz der statischen Bibliothek, da er sich nicht für die Wiederverwendung der erstellten Headereinheiten in anderen Projekten eignet. Aber Sie erhalten immer noch den Leistungsvorteil des Imports einzelner STL-Bibliotheken als Headereinheiten. Um diesen Ansatz auszuprobieren, lesen Sie Ansatz 2: Scannen von Includes nach STL-Headern zum Importieren.

Ansatz 1: Erstellen einer statischen Bibliothek von STL-Bibliothekskopfeinheiten

Die empfohlene Methode zum Verwenden von STL-Bibliotheken als Headereinheiten besteht darin, ein oder mehrere statische Bibliotheksprojekte zu erstellen. Diese Projekte sollten aus den Headern der STL-Bibliothek bestehen, die Sie verwenden möchten. Verweisen Sie dann auf die Bibliotheksprojekte, um diese STL-Headereinheiten zu verwenden. Es ist ähnlich wie die Verwendung gemeinsamer vorkompilierter Header, aber einfacher.

Headereinheiten (und Module), die in einem statischen Bibliotheksprojekt erstellt wurden, sind automatisch für referenzierende Projekte verfügbar, da das Projektsystem dem Compiler automatisch die entsprechende Befehlszeilenoption /headerUnit hinzufügt, damit referenzierende Projekte die Headereinheiten importieren können.

Auf diese Weise wird sichergestellt, dass die Headereinheit für eine bestimmte Header nur einmal erstellt wird. Damit können Sie einige oder alle Headereinheiten importieren, was mit einem PCH nicht möglich ist. Sie können Headereinheiten in beliebiger Reihenfolge einfügen.

In dem folgenden Beispiel erstellen Sie ein statisches Bibliotheksprojekt, das aus den Headereinheiten <iostream> und <vector> besteht. Nach dem Erstellen der Projektmappe verweisen Sie aus einem anderen C++-Projekt auf dieses Projekt mit freigegebenen Headereinheiten. Überall, wo import <iostream>; oder import <vector>; gefunden wird, wird die Headereinheit für diese Bibliothek verwendet, anstatt den Header mit dem Präprozessor zu übersetzen. Dies verbessert die Buildleistung, wie es auch PCH-Dateien tun, wenn derselbe Header in mehreren Dateien enthalten ist. Der Header muss nicht immer wieder von den Dateien verarbeitet werden, die ihn enthalten. Stattdessen wird die bereits verarbeitete kompilierte Headereinheit importiert.

Um eine statische Bibliothek zu erstellen, die die STL-Bibliotheken <iostream> und <vector> enthält, gehen Sie wie folgt vor:

  1. Erstellen Sie ein leeres C++-Projekt. Nennen Sie es SharedPrj.
    Wählen Sie Leeres Projekt für C++ aus den Projekttypen, die im Fenster Neues Projekt erstellen verfügbar sind: Screenshot der Erstellung eines neuen leeren C++-Projekts.

  2. Fügen Sie dem Projekt eine neue C++-Datei hinzu. Ändern Sie den Inhalt der Datei folgendermaßen ab:

    import <iostream>;
import <vector>;

Festlegen von Projekteigenschaften

Legen Sie Projekteigenschaften fest, um die Headereinheiten aus diesem Projekt freizugeben:

  1. Wählen Sie in Visual Studio im Hauptmenü Projekt>Eigenschaften von SharedPrj aus, um das Dialogfeld der Eigenschaftenseiten des Projekts zu öffnen: Screenshot mit den Einstellungen für Konfigurationstyp und C++-Sprachstandard.
  2. Wählen Sie Alle Konfigurationen in der Dropdownliste Konfiguration und dann Alle Plattformen in der Dropdownliste Plattform aus. Diese Einstellungen stellen sicher, dass Ihre Änderungen unabhängig davon gelten, ob Sie für Debug oder Release bauen.
  3. Wählen Sie im linken Bereich des Dialogs Eigenschaftsseiten des Projekts die Option Konfigurationseigenschaften>Allgemein aus.
  4. Ändern Sie den Konfigurationstyp in Statische Bibliothek (.lib).
  5. Ändern Sie den C++-Sprachstandard in ISO C++20 Standard (/std:c++20) (oder höher).
  6. Wählen Sie im linken Bereich des Dialogs Eigenschaftsseiten des Projekts die Option Konfigurationseigenschaften>C/C++>Allgemein aus.
  7. Wählen Sie in der Dropdownliste Quellen nach Modulabhängigkeiten überprüfen Ja aus. (Diese Option veranlasst den Compiler, Ihren Code nach Abhängigkeiten zu durchsuchen, die in Headereinheiten eingebaut werden können): Screenshot, der die Einstellung der Eigenschaft Abhängigkeiten von Scan-Modulen zeigt.
  8. Wählen Sie OK aus, um das Dialogfeld mit den Eigenschaftenseiten des Projekts zu schließen. Erstellen Sie die Projektmappe, indem im Hauptmenü auf Erstellen>Projektmappe erstellen klicken.

Verweis auf die Headereinheit-Bibliothek

Um <iostream> und <vector> als Kopfzeileneinheiten aus der statischen Bibliothek zu importieren, erstellen Sie wie folgt ein Projekt, das auf die statische Bibliothek verweist:

  1. Wenn die aktuelle Projektmappe noch geöffnet ist, wählen Sie im Visual Studio-Menü Datei>Hinzufügen>Neues Projekt aus.

  2. Wählen Sie im Assistenten Neues Projekt erstellen die C++-Vorlage Konsolen-App aus, und wählen Sie Weiter aus.

  3. Geben Sie dem neuen Projekt den Namen Walkthrough. Ändern Sie die Dropdownliste Projektmappe zu Zur Projektmappe hinzufügen. Wählen Sie Erstellen, um das Projekt zu erstellen und es zu Ihrer Projektmappe hinzuzufügen.

  4. Ändern Sie den Inhalt der Quelldatei Walkthrough.cpp wie folgt:

    import <iostream>;
import <vector>;

int main()
{
    std::vector<int> numbers = {0, 1, 2};
    std::cout << numbers[1];
}

Headereinheiten erfordern die Option /std:c++20 (oder höher). Legen Sie den Sprachstandard mithilfe der folgenden Schritte fest:

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt Walkthrough und wählen Sie Eigenschaften aus, um das Dialogfeld Eigenschaftenseiten für das Projekt zu öffnen: Screenshot, der die Einstellung des Sprachstandards auf die Vorschauversion zeigt.
  2. Wählen Sie im linken Bereich des Dialogfelds Eigenschaftenseite des Projekts Walkthrough die Option Konfigurationseigenschaften>Allgemein aus.
  3. Wählen Sie in der Dropdownliste C++-Sprachstandard die Option ISO C++20 Standard (/std:c++20) oder höher aus.
  4. Wählen Sie OK aus, um das Dialogfeld mit den Eigenschaftenseiten des Projekts zu schließen.

Fügen Sie mit den folgenden Schritten im Projekt Walkthrough einen Verweis auf das Projekt SharedPrj hinzu:

  1. Klicken Sie im Projekt Walkthrough auf den Knoten Verweise, und wählen Sie anschließend Verweis hinzufügen aus. Wählen Sie in der Liste der Projekte SharedPrj aus: Screenshot des Dialogfelds „Verweis hinzufügen“. Er wird verwendet, um einen Verweis auf das Projekt Walkthrough hinzuzufügen. Das Hinzufügen dieses Verweises veranlasst das Build-System, die von SharedPrj erstellten Headereinheiten zu verwenden, wenn eine im Walkthrough-Projekt enthaltene import mit einer der in SharedPrj erstellten Headereinheiten übereinstimmt.
  2. Wählen Sie OK aus, um das Dialogfeld Verweis hinzufügen zu schließen.
  3. Klicken Sie mit der rechten Maustaste auf das Projekt Walkthrough, und wählen Sie Als Startprojekt festlegen aus.
  4. Erstellen Sie die Projektmappe. (Verwenden Sie im Hauptmenü Build>Lösung erstellen.) Führen Sie es aus, um zu sehen, ob es die erwartete Ausgabe erzeugt: 1

Der Vorteil dieses Ansatzes ist, dass Sie aus jedem Projekt auf das statische Bibliotheksprojekt verweisen können, um die Headereinheiten wiederzuverwenden. In diesem Beispiel enthält die statische Bibliothek die Headereinheiten <vector> und <iostream>.

Sie können ein monolithisches, statisches Bibliotheksprojekt erstellen, das alle häufig verwendeten STL-Header enthält, die Sie aus Ihren verschiedenen Projekten importieren möchten. Alternativ können Sie kleinere, freigegebene Bibliotheksprojekte für die verschiedenen Gruppierungen von STL-Bibliotheken erstellen, die Sie als Headereinheiten importieren möchten. Verweisen Sie dann bei Bedarf auf diese Projekte mit freigegebenen Headereinheiten.

Das Ergebnis sollte ein höherer Builddurchsatz sein, da das Importieren einer Headereinheit die Arbeit, die der Compiler erledigen muss, erheblich reduziert.

Wenn Sie diesen Ansatz für Ihre eigenen Projekte nutzen, ist es wichtig, dass Sie das statische Bibliotheksprojekt mithilfe von Compileroptionen erstellen, die mit dem verweisenden Projekt kompatibel sind. Beispielsweise sollten STL-Projekte mit der Compileroption /EHsc erstellt werden, um die Ausnahmebehandlung zu aktivieren, und ebenso die Projekte, die auf das statische Bibliotheksprojekt verweisen.

Verwenden Sie /translateInclude

Die Compiler-Option /translateInclude (verfügbar im Dialogfeld Eigenschaftsseiten des Projekts unter C/C++>Allgemein>Includes in Importe übersetzen) erleichtert Ihnen die Verwendung einer Headereinheit-Bibliothek in älteren Projekten, die STL-Bibliotheken mit #include einbinden. Dadurch müssen Sie in Ihrem Projekt nicht mehr die #include-Direktiven in import-Direktiven ändern, haben aber trotzdem den Vorteil, dass Sie die Headereinheiten importieren können, anstatt sie einzubinden.

Wenn Sie zum Beispiel in Ihrem Projekt #include <vector> verwenden und auf eine statische Bibliothek verweisen, die eine Headereinheit für <vector> enthält, müssen Sie in Ihrem Quellcode nicht manuell #include <vector> in import <vector>; ändern. Der Compiler behandelt #include <vector> stattdessen automatisch als import <vector>;. Weitere Informationen finden Sie unter Ansatz 2: Scannen von Includes nach STL-Headern zum Importieren. Nicht alle STL-Headerdateien können zu einer Headereinheit kompiliert werden. Die in Visual Studio enhaltene header-units.json listet auf, welche STL-Headerdateien in Headereinheiten kompiliert werden können. Ein Header, der auf Makros angewiesen ist, um sein Verhalten zu spezifizieren, kann oft nicht in eine Headereinheit kompiliert werden.

Eine #include-Anweisung, die nicht auf eine Headereinheit verweist, wird als normale #include behandelt.

Wiederverwenden von Headereinheiten zwischen Projekten

Headereinheiten, die von einem statischen Bibliotheksprojekt erstellt wurden, sind automatisch für alle direkt und indirekt verweisenden Projekte verfügbar. Es gibt Projekteinstellungen, mit denen Sie auswählen können, welche Headereinheiten automatisch für alle verweisenden Projekte verfügbar sein sollen. Die Einstellungen befinden sich in den Projekteinstellungen unter VC++-Verzeichnisse.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt und wählen Sie Eigenschaften aus, um das Dialogfeld Eigenschaftenseiten für das Projekt zu öffnen.
  2. Wählen Sie im linken Bereich des Dialogfelds Konfigurationseigenschaften>VC++-Verzeichnisse aus: Screenshot: Eigenschaften für öffentliche Projektinhalte, z. B. „Öffentliche Includeverzeichnisse“ und „Alle Headerdateien sind öffentlich“.

Die folgenden Eigenschaften steuern die Sichtbarkeit von Headereinheiten für das Build-System:

  • Öffentliche Includeverzeichnisse geben Projektverzeichnisse für Headereinheiten an, die dem Includepfad in verweisenden Projekten automatisch hinzugefügt werden sollen.
  • Öffentliche C++-Modulverzeichnisse geben an, welche Projektverzeichnisse Headereinheiten enthalten, die zum Verweisen auf Projekte verfügbar sein sollen. Mit dieser Eigenschaft können Sie einige Headereinheiten als öffentlich festlegen. Sie ist für andere Projekte sichtbar, also fügen Sie hier Headereinheiten ein, die Sie freigeben möchten. Wenn Sie diese Einstellung verwenden, geben Sie der Einfachheit halber Öffentliche Include-Verzeichnisse an, um Ihre öffentlichen Header automatisch zum Include-Pfad in referenzierenden Projekten hinzuzufügen.
  • Alle Module sind öffentlich: Die Symbole müssen aus der DLL exportiert werden, wenn Sie Headereinheiten verwenden, die als Teil eines DLL-Projekts erstellt wurden. Um Modulsymbole automatisch zu exportieren, legen Sie diese Eigenschaft auf Ja fest.

Verwenden einer vordefinierten Moduldatei

Die einfachste Möglichkeit zur Wiederverwendung von Headereinheiten zwischen Projektmappen besteht üblicherweise darin, in jeder Projektmappe auf ein Projekt mit freigegebenen Headereinheiten zu verweisen.

Wenn Sie eine kompilierte Headereinheit verwenden müssen, für die Sie nicht über das Projekt verfügen, können Sie den Speicherort der kompilierten .ifc-Datei angeben, damit Sie sie in Ihre Projektmappe importieren können. So greifen Sie auf diese Einstellung zu:

  1. Wählen Sie in Visual Studio im Hauptmenü Projekt>Eigenschaften aus, um das Dialogfeld der Eigenschaftenseiten des Projekts zu öffnen.
  2. Wählen Sie im linken Bereich Konfigurationseigenschaften>C/C++>Allgemein aus.
  3. Fügen Sie unter Zusätzliche Modulabhängigkeiten die Module hinzu, auf die Sie verweisen möchten, getrennt durch Semikolon. Hier finden Sie ein Beispiel für das Format, das Sie für zusätzliche Modulabhängigkeiten verwenden sollten: ModuleName1=Path\To\ModuleName1.ifc; ModuleName2=Path\To\ModuleName2.ifcDer Screenshot zeigt die Eigenschaften der Projekteigenschaftsseiten unter „Konfigurationseigenschaften“, „C/C++“, „Allgemein“, mit der Auswahl „Zusätzliche Modulabhängigkeiten“.

Auswählen aus mehreren Kopien einer Headereinheit

Wenn Sie auf Projekte verweisen, die mehrere Headereinheiten erstellen, entweder mit demselben Namen oder für dieselbe Headerdatei, müssen Sie angeben, welche verwendet werden soll. Sie haben möglicherweise verschiedene Versionen der Headereinheit mit unterschiedlichen Compiler-Einstellungen erstellt und müssen diejenige angeben, die Ihren Projekteinstellungen entspricht.

Verwenden Sie die Eigenschaft Zusätzliche Abhängigkeiten der Headereinheit, um Konflikte aufzulösen, indem Sie angeben, welche Headereinheit verwendet werden soll. Andernfalls ist es nicht möglich, vorherzusagen, welcher von ihnen ausgewählt wird.

So legen Sie die Eigenschaft Zusätzliche Abhängigkeiten der Headereinheit fest:

  1. Wählen Sie in Visual Studio im Hauptmenü Projekt>Eigenschaften aus, um das Dialogfeld der Eigenschaftenseiten des Projekts zu öffnen.
  2. Wählen Sie im linken Bereich Konfigurationseigenschaften>C/C++>Allgemein aus.
  3. Geben Sie unter Zusätzliche Abhängigkeiten der Headereinheit an, welche Module oder Dateien der Headereinheiten verwendet werden sollen, um Probleme aufzulösen. Verwenden Sie dieses Format für Zusätzliche Abhängigkeiten der Headereinheit: Path\To\Header1.h= Path\To\HeaderUnit1.ifc;Path\To\Header2.h= Path\To\ HeaderUnit2.ifcScreenshot der Einstellung „Zusätzliche Abhängigkeiten der Headereinheit“ im Dialogfeld „Eigenschaftenseiten des Projekts“.

Wichtig

Stellen Sie sicher, dass Projekte, die Headereinheiten gemeinsam nutzen, mit kompatiblen Kompilierungsoptionen erstellt werden. Wenn Sie beim Implementieren der Headereinheit andere Kompilierungsoptionen als bei deren Erstellung verwenden, gibt der Compiler Warnungen aus.

Hinweis

Um Headereinheiten zu verwenden, die als Teil eines DLL-Projekts erstellt wurden, legen Sie Alle Module sind öffentlich auf Ja fest.

Ansatz 2: Scannen von Includes nach STL-Headern zum Importieren

Eine andere Möglichkeit, STL-Bibliotheken zu importieren, besteht darin, Visual Studio nach den STL-Headern suchen zu lassen, die Sie in Ihrem Projekt #include verwenden, und diese in Headereinheiten zu kompilieren. Der Compiler importiert diese Header dann anstatt sie zu integrieren.

Diese Option ist praktisch, wenn Ihr Projekt viele STL-Headerdateien in vielen Dateien enthält oder wenn der Durchsatz beim Erstellen nicht entscheidend ist. Diese Option garantiert nicht, dass eine Headereinheit für einen bestimmten Header nur einmal erstellt wird. Sie ist jedoch nützlich, wenn Sie eine große Codebasis haben: Sie brauchen Ihren Quellcode nicht zu ändern, um die Vorteile der Headereinheiten für viele der von Ihnen verwendeten STL-Bibliotheken zu nutzen.

Dieser Ansatz ist weniger flexibel als der Ansatz der statischen Bibliothek, da er sich nicht für die Wiederverwendung der erstellten Headereinheiten in anderen Projekten eignet. Dieser Ansatz ist für größere Projekte möglicherweise nicht geeignet: Er garantiert keine optimale Erstellungszeit, da alle Quellen nach #include-Anweisungen durchsucht werden müssen.

Nicht alle Headerdateien können automatisch in Headereinheiten konvertiert werden. Zum Beispiel sollten Header, die von der bedingten Kompilierung über Makros abhängig sind, nicht in Headereinheiten umgewandelt werden. Es gibt eine Zulassungsliste in Form einer header-units.json-Datei für die STL-Header, die der Compiler verwendet, wenn /translateInclude angegeben wird. Sie bestimmt, welche STL-Header in Headereinheiten kompiliert werden können. Die Datei header-units.json befindet sich im Installationsverzeichnis für Visual Studio. Beispiel: %ProgramFiles%\Microsoft Visual Studio\2022\Enterprise\VC\Tools\MSVC\14.30.30705\include\header-units.json. Wenn sich die STL-Headerdatei nicht in der Liste befindet, wird sie als normale #include behandelt und nicht als Headereinheit importiert. Ein weiterer Vorteil der Datei header-units.json besteht darin, dass die Symbolduplizierung in den integrierten Headereinheiten verhindert wird. Das heißt, wenn die Kompilierung einer Headereinheit einen anderen Bibliotheksheader mehrfach einbindet, werden die Symbole nicht dupliziert.

Um diesen Ansatz auszuprobieren, erstellen Sie ein Projekt, das zwei STL-Bibliotheken enthält. Ändern Sie dann die Eigenschaften des Projekts so, dass die Bibliotheken als Headereinheiten importiert werden, anstatt sie einzubinden, wie im nächsten Abschnitt beschrieben.

Erstellen eines C++-Konsolen-App-Projekts

Folgen Sie diesen Schritten, um ein Projekt zu erstellen, das zwei STL-Bibliotheken enthält: <iostream> und <vector>.

  1. Erstellen Sie in Visual Studio ein neues C++-Konsolen-App-Projekt.

  2. Ersetzen Sie den Inhalt in der Quelldatei wie folgt:

    #include <iostream>;
#include <vector>;

int main()
{
    std::vector<int> numbers = {0, 1, 2};
    std::cout << numbers[1];
}

Festlegen von Projektoptionen und Ausführen des Projekts

Mit den folgenden Schritten legen Sie die Option fest, die den Compiler veranlasst, nach eingebundenen Headern zu suchen, um sie in Headereinheiten zu übersetzen. Sie legen auch die Option fest, die den Compiler veranlasst, #include, die als Headereinheiten behandelt werden können, so zu behandeln, als ob Sie dafür import geschrieben hätten.

  1. Wählen Sie in Visual Studio im Hauptmenü Projekt>Eigenschaften aus, um das Dialogfeld der Eigenschaftenseiten des Projekts zu öffnen.
  2. Wählen Sie Alle Konfigurationen in der Dropdownliste Konfiguration und dann Alle Plattformen in der Dropdownliste Plattform aus. Diese Einstellungen stellen sicher, dass Ihre Änderungen unabhängig davon gelten, ob Sie für Debug oder Release und andere Konfigurationen erstellen.
  3. Wählen Sie im linken Bereich Konfigurationseigenschaften>C/C++>Allgemein aus.
  4. Legen Sie unter Quellen auf Modulabhängigkeiten überprüfen die Option Ja fest. Diese Einstellung stellt sicher, dass alle kompatiblen Headerdateien in Headereinheiten kompiliert werden.
  5. Legen Sie Includes in Importe übersetzen auf Ja fest. Diese Einstellung kompiliert die STL-Header-Dateien, die in der Datei header-unit.json aufgeführt sind, als Headereinheiten und importiert sie dann, anstatt sie mit dem Präprozessor mit #include einzubinden. Screenshot: Einstellung „Quellen auf Modulabhängigkeiten überprüfen“ auf der Seite mit den Projekteigenschaften.
  6. Wählen Sie OK, um Ihre Änderungen zu speichern und das Dialogfeld Eigenschaftsseiten des Projekts zu schließen.

Die Option /std:c++20 oder später muss Headereinheiten verwenden. Zum Ändern des vom Compiler verwendeten C++-Sprachstandards:

  1. Wählen Sie in Visual Studio im Hauptmenü Projekt>Eigenschaften aus, um das Dialogfeld der Eigenschaftenseiten des Projekts zu öffnen.
  2. Wählen Sie Alle Konfigurationen in der Dropdownliste Konfiguration und dann Alle Plattformen in der Dropdownliste Plattform aus. Diese Einstellungen stellen sicher, dass Ihre Änderungen unabhängig davon gelten, ob Sie für Debug oder Release und andere Konfigurationen erstellen.
  3. Wählen Sie im linken Bereich des Dialogs Eigenschaftsseiten des Projekts die Option Konfigurationseigenschaften>Allgemein aus.
  4. Wählen Sie in der Dropdownliste C++-Sprachstandard die Option ISO C++20 Standard (/std:c++20) oder höher aus.
  5. Wählen Sie OK, um Ihre Änderungen zu speichern und das Dialogfeld Eigenschaftsseiten des Projekts zu schließen.
  6. Erstellen Sie die Projektmappe, indem im Hauptmenü Erstellen>Projektmappe erstellen auswählen.

Führen Sie die Projektmappe aus, um zu überprüfen, ob sie die erwartete Ausgabe erzeugt: 1

Die wichtigste Überlegung bei der Entscheidung für diesen Ansatz ist die Abwägung zwischen der Benutzerfreundlichkeit und den Kosten für das Überprüfen aller Dateien, um zu bestimmen, welche Headerdateien als Headereinheiten erstellt werden sollen.

Siehe auch

Vergleichen von Headereinheiten, Modulen und vorkompilierten Headern
Tutorial: Importieren der C++-Standardbibliothek mithilfe von Modulen
Exemplarische Vorgehensweise: Erstellen und Importieren von Headereinheiten in Ihren Visual C++-Projekten
/translateInclude