Exemplarische Vorgehensweise: Importieren von STL-Bibliotheken als Headereinheiten

In dieser exemplarischen Vorgehensweise wird gezeigt, wie Sie C++-Standardvorlagenbibliotheksbibliotheken (STL) als Kopfzeileneinheiten in Visual Studio importieren. Eine noch schnellere und robustere Methode zum Importieren der Standardbibliothek finden Sie im Lernprogramm: Importieren der C++-Standardbibliothek mithilfe von Modulen.

Das Importieren eines STL-Headers als Kopfzeileneinheit ist einfacher als die Verwendung von vorkompilierten Headerdateien. Kopfzeileneinheiten sind einfacher einzurichten und zu verwenden, sind wesentlich kleiner auf dem Datenträger, bieten ähnliche Leistungsvorteile und sind flexibler als ein gemeinsam genutzter PCH.

Ausführlichere Informationen zu den Kopfzeileneinheiten und den vorteilen, die sie bieten, finden Sie unter Was ist eine Kopfzeileneinheit?. Informationen zum Kontrast von Kopfzeileneinheiten mit anderen Methoden zum Importieren der Standardbibliothek finden Sie unter Vergleichen von Headereinheiten, Modulen und vorkompilierten Headern.

Voraussetzungen

Um Kopfzeileneinheiten zu verwenden, verwenden Sie Visual Studio 2022 oder höher oder Visual Studio 2019, Version 16.11 oder höher. Die /std:c++20 Option (oder höher) ist erforderlich, um Kopfzeileneinheiten zu verwenden.

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

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 hat eine .ifc Erweiterung.

Der empfohlene Ansatz besteht darin, eine statische Bibliothek zu erstellen, die die integrierten Kopfzeileneinheiten für die zu verwendenden STL-Header enthält. Verweisen Sie dann auf diese Bibliothek und import deren Kopfzeileneinheiten. Dieser Ansatz kann zu schnelleren Builds und einer besseren Wiederverwendung führen. Informationen zum Ausprobieren dieses Ansatzes finden Sie unter Ansatz 1: Erstellen einer statischen Bibliothek von STL-Bibliothekskopfeinheiten.

Ein weiterer Ansatz besteht darin, visual Studio nach den STL-Headern #include in Ihrem Projekt zu suchen, sie in Kopfzeileneinheiten zu kompilieren und import nicht #include in diesen Headern. 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 integrierten Kopfzeileneinheiten in anderen Projekten eignet. Sie erhalten jedoch weiterhin den Leistungsvorteil beim Importieren einzelner STL-Bibliotheken als Kopfzeileneinheiten. Informationen zum Testen dieses Ansatzes finden Sie unter Ansatz 2: Scan umfasst STL-Header 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 STL-Bibliothekskopfeinheiten bestehen, die Sie verwenden möchten. Verweisen Sie dann auf die Bibliotheksprojekte, um diese STL-Headereinheiten zu nutzen. Es ist vergleichbar mit der Verwendung freigegebener vorkompilierter Header, aber einfacher.

Headereinheiten (und Module), die in einem statischen Bibliotheksprojekt erstellt wurden, stehen automatisch zum Verweisen auf Projekte zur Verfügung, da das Projektsystem dem Compiler automatisch die entsprechende /headerUnit Befehlszeilenoption hinzufügt, sodass verweisende Projekte die Headereinheiten importieren können.

Durch diesen Ansatz wird sichergestellt, dass die Kopfzeileneinheit für einen bestimmten Header nur einmal erstellt wird. Sie können einige oder alle Kopfzeileneinheiten importieren, die mit einem PCH nicht möglich sind. Sie können Kopfzeileneinheiten in beliebiger Reihenfolge einschließen.

Im folgenden Beispiel erstellen Sie ein statisches Bibliotheksprojekt, das aus den <iostream> Einheiten und <vector> Kopfzeilen besteht. Nach dem Erstellen der Projektmappe verweisen Sie aus einem anderen C++-Projekt auf dieses Projekt mit freigegebenen Headereinheiten. import <iostream>; Überall oder import <vector>; gefunden wird, wird die integrierte Kopfzeileneinheit für diese Bibliothek verwendet, anstatt den Header mit dem Präprozessor zu übersetzen. Es verbessert die Buildleistung, z. B. PCH-Dateien, 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.

Führen Sie die folgenden Schritte aus, um eine statische Bibliothek zu erstellen, die die STL-Bibliotheken <iostream> enthält. <vector>Führen Sie die folgenden Schritte aus:

1. Erstellen Sie ein leeres C++-Projekt. Nennen Sie es SharedPrj.
   Wählen Sie "Leeres Projekt für C++" aus den projekttypen aus, die im Fenster "Neues Projekt erstellen" verfügbar sind:

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

   import <iostream>;
   import <vector>;
   

Festlegen von Projekteigenschaften

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

1. Wählen Sie im Menü "Visual Studio Standard" die Option "Project>SharedPrj-Eigenschaften" aus, um das Dialogfeld "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 gelten, unabhängig davon, ob Sie zum Debuggen oder Freigeben erstellen.
3. Wählen Sie im linken Bereich des Dialogfelds "Eigenschaftenseiten 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 Dialogfelds "Eigenschaftenseiten des Projekts" die Option "Konfigurationseigenschaften>C/C++>Allgemein" aus.
7. Wählen Sie in der Dropdownliste "Quellen für Modulabhängigkeiten überprüfen" "Ja" aus. (Diese Option bewirkt, dass der Compiler Ihren Code auf Abhängigkeiten überprüft, die in Headereinheiten integriert werden können):
8. Wählen Sie 'OK ' aus, um das Dialogfeld 'Eigenschaftenseiten' des Projekts zu schließen. Erstellen Sie die Projektmappe, indem im Hauptmenü auf Erstellen>Projektmappe erstellen klicken.

Verweisen auf die Kopfzeileneinheitsbibliothek

Um Headereinheiten aus der statischen Bibliothek zu importieren <iostream> und <vector> zu verwenden, erstellen Sie ein Projekt, das wie folgt 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 zum Erstellen eines neuen Projekts die C++ -Konsolen-App-Vorlage und dann "Weiter" aus.

3. Benennen Sie das neue Projekt Exemplarische Vorgehensweise. Ändern Sie die Dropdownliste "Lösung " in " Zu Lösung hinzufügen". Wählen Sie "Erstellen" aus, um das Projekt zu erstellen, und fügen Sie es Ihrer Lösung hinzu.

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];
   }
   

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

1. Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf das Projekt "Exemplarische Vorgehensweise", und wählen Sie "Eigenschaften" aus, um das Dialogfeld "Eigenschaftenseiten" des Projekts zu öffnen:
2. Wählen Sie im linken Bereich des Dialogfelds "Eigenschaftenseiten für exemplarische Vorgehensweise" die Option "Konfigurationseigenschaften>allgemein" aus.
3. Wählen Sie in der Dropdownliste C++-Sprachstandard iso C++20 Standard (/std:c++20) (oder höher)aus.
4. Wählen Sie 'OK ' aus, um das Dialogfeld 'Eigenschaftenseiten' des Projekts zu schließen.

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

1. Klicken Sie im Projekt Walkthrough auf den Knoten Verweise, und wählen Sie anschließend Verweis hinzufügen aus. Wählen Sie "SharedPrj " in der Liste der Projekte aus: Wenn Sie diesen Verweis hinzufügen, verwendet das Buildsystem die von SharedPrj erstellten Headereinheiten, wenn ein import Objekt im Walkthrough-Projekt mit einer der integrierten Headereinheiten in SharedPrj ü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 Build>Solution on the Standard menu.) Führen Sie sie aus, um zu sehen, dass sie 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 <vector> Einheiten und <iostream> Kopfzeilen.

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 mit Ihren eigenen Projekten verwenden, erstellen Sie das statische Bibliotheksprojekt mit Compileroptionen, die mit dem Projekt kompatibel sind, das darauf verweist. 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 /translateInclude Compileroption (verfügbar im Dialogfeld "Eigenschaftenseiten des Projekts" unter "C/C++>General>Translate Includes to Imports") erleichtert Ihnen die Verwendung einer Kopfzeileneinheitsbibliothek in älteren Projekten, die #include die STL-Bibliotheken haben. Es macht es unnötig, Direktiven import in Ihr Projekt zu ändern#include, während Sie dennoch den Vorteil erhalten, die Kopfzeileneinheiten zu importieren, anstatt sie einzuschlussen.

Wenn Sie beispielsweise in Ihrem Projekt vorhanden sind #include <vector> und auf eine statische Bibliothek verweisen, die eine Kopfzeileneinheit enthält <vector>, müssen Sie in Ihrem Quellcode nicht manuell wechseln #include <vector>import <vector>; . Stattdessen behandelt #include <vector> der Compiler automatisch als import <vector>;. Weitere Informationen zu diesem Ansatz finden Sie unter Ansatz 2: Scan umfasst STL-Header zum Importieren. Nicht alle STL-Headerdateien können zu einer Kopfzeileneinheit kompiliert werden. Die header-units.json mit Visual Studio ausgelieferten Listen, welche STL-Headerdateien in Kopfzeileneinheiten kompiliert werden können. Ein Header, der auf Makros basiert, um sein Verhalten anzugeben, kann häufig nicht in eine Kopfzeileneinheit kompiliert werden.

Eine #include Anweisung, die nicht auf eine Kopfzeileneinheit verweist, wird normal #includebehandelt.

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 in Projektmappen-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie "Eigenschaften" aus, um das Dialogfeld "Eigenschaftenseiten" des Projekts zu öffnen.
2. Wählen Sie im linken Bereich des Dialogfelds konfigurationseigenschaften>VC++-Verzeichnisse aus:

Die folgenden Eigenschaften steuern die Sichtbarkeit von Kopfzeileneinheiten auf das Buildsystem:

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

Verwenden einer vordefinierten Moduldatei

In der Regel besteht die einfachste Möglichkeit zum Wiederverwenden von Kopfzeileneinheiten zwischen Lösungen darin, von jeder Lösung aus auf ein freigegebenes Kopfzeileneinheitsprojekt zu verweisen.

Wenn Sie eine integrierte Kopfzeileneinheit verwenden müssen, für die Sie nicht über das Projekt verfügen, können Sie angeben, wo sich die integrierte .ifc Datei befindet, damit Sie sie in Ihre Projektmappe importieren können. So greifen Sie auf diese Einstellung zu:

1. Wählen Sie >im Menü Standard Projekteigenschaften aus, um das Dialogfeld "Eigenschaftenseiten" des Projekts zu öffnen.
2. Wählen Sie im linken Bereich des Dialogfelds "Konfigurationseigenschaften>C/C++>Allgemein" aus.
3. Fügen Sie in "Zusätzliche Modulabhängigkeiten" die zu referenzierenden Module hinzu, getrennt durch Semikolons. Hier ist ein Beispiel für das Format, das für zusätzliche Modulabhängigkeiten verwendet werden soll: ModuleName1=Path\To\ModuleName1.ifc; ModuleName2=Path\To\ModuleName2.ifc

Auswählen aus mehreren Kopien einer Headereinheit

Wenn Sie auf Projekte verweisen, die mehrere Kopfzeileneinheiten erstellen, entweder mit demselben Namen oder für dieselbe Headerdatei, müssen Sie angeben, welcher verwendet werden soll. Möglicherweise haben Sie unterschiedliche Versionen der Headereinheit, die mit unterschiedlichen Compilereinstellungen erstellt wurde, z. B. und müssen die Version angeben, die Ihren Projekteinstellungen entspricht.

Verwenden Sie die Eigenschaft "Additional Header Unit Dependencies" des Projekts, um Kollisionen zu beheben, indem Sie angeben, welche Kopfzeileneinheit verwendet werden soll. Andernfalls ist es nicht möglich, vorherzusagen, welches ausgewählt wird.

So legen Sie die Eigenschaft "Additional Header Unit Dependencies " fest:

1. Wählen Sie >im Menü Standard Projekteigenschaften aus, um das Dialogfeld "Eigenschaftenseiten" des Projekts zu öffnen.
2. Wählen Sie im linken Bereich des Dialogfelds "Konfigurationseigenschaften>C/C++>Allgemein" aus.
3. Geben Sie an, welche Module oder Headereinheitsdateien in zusätzlichen Abhängigkeiten von Headereinheiten zum Auflösen von Kollisionen verwendet werden sollen. Verwenden Sie dieses Format für zusätzliche Kopfzeileneinheitsabhängigkeiten: Path\To\Header1.h= Path\To\HeaderUnit1.ifc;Path\To\Header2.h= Path\To\ HeaderUnit2.ifc

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: Scan umfasst STL-Header zum Importieren

Eine weitere Möglichkeit zum Importieren von STL-Bibliotheken besteht darin, visual Studio nach den STL-Headern #include in Ihrem Projekt zu suchen und in Kopfzeileneinheiten zu kompilieren. Der Compiler importiert dann und nicht diese Header.

Diese Option ist praktisch, wenn Ihr Projekt viele STL-Headerdateien für viele Dateien enthält oder wenn der Builddurchsatz nicht wichtig ist. Diese Option garantiert nicht, dass eine Kopfzeileneinheit für eine bestimmte Headerdatei nur einmal erstellt wird. Es ist jedoch hilfreich, wenn Sie über eine große Codebasis verfügen: Sie müssen den Quellcode nicht ändern, um die Vorteile von Headereinheiten für viele der verwendeten STL-Bibliotheken zu nutzen.

Dieser Ansatz ist weniger flexibel als der ansatz der statischen Bibliothek, da er sich nicht zur Wiederverwendung der integrierten Kopfzeileneinheiten in anderen Projekten eignet. Dieser Ansatz eignet sich möglicherweise nicht für größere Projekte: Es garantiert keine optimale Buildzeit, da alle Quellen nach #include Anweisungen gescannt werden müssen.

Nicht alle Headerdateien können automatisch in Kopfzeileneinheiten konvertiert werden. Beispielsweise sollten Kopfzeilen, die von der bedingten Kompilierung über Makros abhängen, nicht in Kopfzeileneinheiten konvertiert werden. Es gibt eine Zulassungsliste in Form einer header-units.jsonDatei für die STL-Header, die der Compiler verwendet, wenn /translateInclude angegeben wird. Er bestimmt, welche STL-Header in Kopfzeileneinheiten kompiliert werden können. Die header-units.json Datei befindet sich unter dem 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 normal #include behandelt, anstatt sie als Kopfzeileneinheit zu importieren. Ein weiterer Vorteil der header-units.json Datei besteht darin, dass die Symbolduplizierung in den integrierten Headereinheiten verhindert wird. Wenn das Kompilieren einer Kopfzeileneinheit mehrere Male in einen anderen Bibliotheksheader führt, 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 sie die Bibliotheken als Kopfzeileneinheiten importiert, anstatt sie einzuschlussen, wie im nächsten Abschnitt beschrieben.

Erstellen eines C++-Konsolen-App-Projekts

Führen Sie die folgenden Schritte aus, 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 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

Die folgenden Schritte legen die Option fest, die bewirkt, dass der Compiler nach eingeschlossenen Headern sucht, die in Headereinheiten übersetzt werden. Sie legen auch die Option fest, die bewirkt, dass der Compiler so behandelt #include wird, als ob Sie für Headerdateien geschrieben import haben, die als Headereinheiten behandelt werden können.

1. Wählen Sie >im Menü Standard Projekteigenschaften aus, um das Dialogfeld "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 angewendet werden, unabhängig davon, ob Sie für das Debuggen oder freigeben oder andere Konfigurationen erstellen.
3. Wählen Sie im linken Bereich des Dialogfelds "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 Kopfzeileneinheiten kompiliert werden.
5. Set Translate Includes to Imports to Yes. Diese Einstellung kompiliert die STL-Headerdateien, die in der header-unit.json Datei als Headereinheiten aufgeführt sind, und importiert sie dann, anstatt den Präprozessor für sie zu #include verwenden.
6. Wählen Sie "OK " aus, um Ihre Änderungen zu speichern und das Dialogfeld "Eigenschaftenseiten" des Projekts zu schließen.

Die /std:c++20 Option oder höher ist erforderlich, um Kopfzeileneinheiten zu verwenden. So ändern Sie den vom Compiler verwendeten C++-Sprachstandard:

1. Wählen Sie >im Menü Standard Projekteigenschaften aus, um das Dialogfeld "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 angewendet werden, unabhängig davon, ob Sie für das Debuggen oder freigeben oder andere Konfigurationen erstellen.
3. Wählen Sie im linken Bereich des Dialogfelds "Eigenschaftenseiten des Projekts" die Option "Konfigurationseigenschaften>allgemein" aus.
4. Wählen Sie in der Dropdownliste für C++-Sprachstandard ISO C++20 Standard (/std:c++20) (oder höher)aus.
5. Wählen Sie "OK " aus, um Ihre Änderungen zu speichern und das Dialogfeld "Eigenschaftenseiten" des Projekts zu schließen.
6. Erstellen Sie im Menü Standard die Projektmappe, indem Sie "Projektmappe erstellen">auswählen.

Führen Sie die Lösung aus, um zu überprüfen, ob die erwartete Ausgabe erzeugt wird: 1

Die Standard überlegen, ob dieser Ansatz verwendet werden soll, ist das Gleichgewicht zwischen Komfort und Kosten für das Scannen aller Dateien, um zu bestimmen, welche Headerdateien als Kopfzeileneinheiten erstellt werden sollen.

Siehe auch

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