Tutorial: Importieren der C++-Standardbibliothek mithilfe von Modulen über die Befehlszeile

  • Artikel

Erfahren Sie, wie Sie die C++-Standardbibliothek mithilfe von C++-Bibliotheksmodulen importieren. Dies führt zu einer schnelleren Kompilierung und ist robuster als die Verwendung von Headerdateien oder Headereinheiten oder vorkompilierten Headern (PCH).

In diesem Tutorial erfahren Sie mehr über:

  • So importieren Sie die Standardbibliothek als Modul aus der Befehlszeile.
  • Die Vorteile der Leistung und Benutzerfreundlichkeit von Modulen.
  • Die beiden Standardbibliotheksmodule std und std.compat sowie der Unterschied zwischen ihnen.

Voraussetzungen

Dieses Tutorial erfordert Visual Studio 2022 17.5 oder höher.

Einführung in Standardbibliotheksmodule

Die Semantik von Headerdateien kann sich je nach Makrodefinitionen und der Reihenfolge, in der Sie diese einbinden, ändern, und sie verlangsamen die Kompilierung. Module lösen diese Probleme.

Es ist jetzt möglich, die Standardbibliothek als Modul zu importieren, anstatt als ein Gewirr von Headerdateien. Dies ist viel schneller und stabiler als das Einschließen von Headerdateien oder Headereinheiten oder vorkompilierten Headern (PCH).

Die C++23-Standardbibliothek führt zwei benannte Module ein: std und std.compat:

  • std exportiert die im Namespace der C++-Standardbibliothek definierten Deklarationen und Namen std wie beispielsweise std::vector. Außerdem werden die Inhalte von C-Wrapper-Headern exportiert wie beispielsweise <cstdio> und <cstdlib>, welche Funktionen wie std::printf() bereitstellen. C-Funktionen, die im globalen Namespace definiert sind, wie beispielsweise ::printf(), werden nicht exportiert. Dies verbessert die Situation, in der ein C-Wrapper-Header wie beispielsweise <cstdio>auch C-Header-Dateien wie beispielsweise stdio.h enthält, welche die Versionen des globalen C-Namespaces einbringen. Dies ist kein Problem, wenn Sie std importieren.
  • std.compat exportiert alles in std und fügt die globalen C-Runtime-Namespaces wie beispielsweise ::printf, ::fopen, ::size_t, ::strlen usw. hinzu. Das std.compat-Modul erleichtert die Arbeit mit Codebasen, die auf viele C-Runtime-Funktionen/-typen im globalen Namespace verweisen.

Der Compiler importiert die gesamte Standardbibliothek, wenn Sie import std; oder import std.compat; verwenden, und zwar schneller, als wenn Sie eine einzelne Headerdatei einbringen. Es ist schneller, die gesamte Standardbibliothek mit import std; (oderimport std.compat ) einzubringen als zum Beispiel mit #include <vector>.

Da benannte Module keine Makros verfügbar machen, sind Makros wie assert, errno, offsetof, va_arg und andere nicht verfügbar, wenn Sie std oder std.compat importieren. Siehe Überlegungen zu benannten Modulen in der Standardbibliothek für Umgehungslösungen.

Informationen zu C++-Modulen

Headerdateien sind dergestalt, wie Deklarationen und Definitionen zwischen Quelldateien in C++ freigegeben werden. Vor Standardbibliotheksmodulen fügen Sie den Teil der Standardbibliothek ein, den Sie mit einer Anweisung wie beispielsweise #include <vector> benötigen. Headerdateien sind fragil und schwierig zu verfassen, da sich ihre Semantik je nach der Reihenfolge, in der Sie diese einfügen, oder je nachdem, ob bestimmte Makros definiert sind, ändern kann. Außerdem verlangsamen sie die Kompilierung, da sie von jeder Quelldatei, die sie enthält, erneut verarbeitet werden.

C++20 führt eine moderne Alternative namens Module ein. In C++23 konnten wir den Modulsupport großschreiben, um benannte Module zur Darstellung der Standardbibliothek einzuführen.

Wie Headerdateien können Sie mithilfe von Modulen Deklarationen und Definitionen über Quelldateien hinweg freigeben. Im Gegensatz zu Headerdateien sind Module jedoch nicht fragil und sind einfacher zu verfassen, da sich ihre Semantik aufgrund von Makrodefinitionen oder der Reihenfolge, in der Sie diese importieren, nicht ändert. Der Compiler kann Module viel schneller verarbeiten als #include-Dateien verarbeiten und benötigt zur Kompilierzeit weniger Arbeitsspeicher. Benannte Module geben keine Makrodefinitionen oder private Implementierungsdetails preis.

Ausführliche Informationen zu Modulen finden Sie in der Übersicht über Module in C++ In diesem Artikel wird auch die Verwendung der C++-Standardbibliothek als Modul erläutert, allerdings auf eine ältere und experimentelle Weise.

Dieser Artikel demonstriert die neue und beste Art, die Standardbibliothek zu nutzen. Weitere Informationen zu alternativen Methoden zum Nutzen der Standardbibliothek finden Sie unter Vergleichen von Headereinheiten, Modulen und vorkompilierten Headern.

Importieren der Standardbibliothek mit std

Die folgenden Beispiele veranschaulichen, wie Sie die Standardbibliothek als Modul mit dem Befehlszeilencompiler nutzen können. Informationen darüber, wie Sie dies in der Visual Studio-IDE tun können, finden Sie unter Erstellen von ISO C++23-Standardbibliotheksmodulen.

Die Anweisung import std; oder import std.compat; importiert die Standardbibliothek in Ihre Anwendung. Aber zuerst müssen Sie die Module der Standardbibliothek in die Binärform kompilieren. Die folgenden Schritte veranschaulichen, wie das funktioniert.

Beispiel: Erstellen und Importieren von std

  1. Öffnen Sie eine x86 Native Tools-Eingabeaufforderung für VS: Geben Sie im Windows-Startmenü x86 nativ ein und die Eingabeaufforderung sollte in der Liste der Anwendungen erscheinen. Stellen Sie sicher, dass die Eingabeaufforderung für Visual Studio 2022, Version 17.5 oder höher, ist. Sie erhalten Fehlermeldungen, wenn Sie die falsche Version der Eingabeaufforderung verwenden. Die in diesem Tutorial verwendeten Beispiele gelten für die CMD-Shell.

  2. Erstellen Sie ein Verzeichnis wie beispielsweise %USERPROFILE%\source\repos\STLModules und machen Sie es zum aktuellen Verzeichnis. Wenn Sie ein Verzeichnis auswählen, auf das Sie keinen Schreibzugriff haben, erhalten Sie während der Kompilierung Fehlermeldungen.

  3. Kompilieren Sie das Modul namens std mit dem folgenden Befehl:

    cl /std:c++latest /EHsc /nologo /W4 /c "%VCToolsInstallDir%\modules\std.ixx"

    Wenn Fehler auftreten, stellen Sie sicher, dass Sie die richtige Version der Eingabeaufforderung verwenden.

    Kompilieren Sie das Modul namens std mit den gleichen Compilereinstellungen, die Sie auch für den Code verwenden möchten, der das erstellte Modul importiert. Wenn Sie eine Lösung mit mehreren Projekten haben, können Sie das Modul mit dem Namen der Standardbibliothek einmal kompilieren und dann in allen Ihren Projekten darauf verweisen, indem Sie die /reference-Compileroption verwenden.

    Mit dem vorherigen Compilerbefehl gibt der Compiler zwei Dateien aus:

    • std.ifc ist die kompilierte Binärdarstellung der benannten Modulschnittstelle, die der Compiler zur Verarbeitung der import std;-Anweisung heranzieht. Dies ist ein Artefakt, das nur die Kompilierzeit betrifft. Es wird nicht mit Ihrer Anwendung ausgeliefert.
    • std.obj enthält die Implementierung des benannten Moduls. Fügen Sie std.obj der Befehlszeile hinzu, wenn Sie die Beispielanwendung kompilieren, um die Funktionen, die Sie aus der Standardbibliothek verwenden, statisch mit Ihrer Anwendung zu verknüpfen.

    Die wichtigsten Befehlszeilenoptionen in diesem Beispiel sind:

    Schalter Bedeutung
    /std:c++:latest Verwenden Sie die neueste Version des C++-Sprachstandards und der Bibliothek. Obwohl die Modulunterstützung verfügbar ist unter /std:c++20, benötigen Sie die neueste Standardbibliothek, um Unterstützung für Standardbibliotheken mit benannten Modulen zu erhalten.
    /EHsc Verwenden Sie die C++-Ausnahmebehandlung, mit Ausnahme der markierten extern "C"-Funktionen.
    /W4 Die Verwendung von /W4 wird im Allgemeinen empfohlen, insbesondere für neue Projekte, da damit alle Warnungen der Ebenen 1, 2 und 3 sowie die meisten Warnungen der Ebene 4 (informativ) aktiviert werden, was Ihnen helfen kann, potenzielle Probleme frühzeitig zu erkennen. Es liefert im Wesentlichen lint-ähnliche Warnungen, die dazu beitragen können, dass möglichst wenige schwer zu findende Codefehler auftreten.
    /c Kompilieren Sie ohne Verknüpfung, da wir an dieser Stelle nur die binär benannte Modulschnittstelle erstellen.

    Sie können den Objektdateinamen und den Namen der benannten Modulschnittstellendatei mit den folgenden Schaltern steuern:

    • /Fo legt den Namen der Objektdatei fest. Beispielsweise /Fo:"somethingelse". Standardmäßig verwendet der Compiler denselben Namen für die Objektdatei wie die Modulquelldatei (.ixx), die Sie kompilieren. Im Beispiel ist der Objektdateiname std.obj standardmäßig vorhanden, da die Moduldatei std.ixx kompiliert wird.
    • /ifcOutput legt den Namen der benannten Modulschnittstellendatei (.ifc) fest. Beispielsweise /ifcOutput "somethingelse.ifc". Standardmäßig verwendet der Compiler denselben Namen für die Modulschnittstellendatei (.ifc) wie die Modulquelldatei (.ixx), die Sie kompilieren. Im Beispiel wird std.ifc die generierte ifc-Datei standardmäßig erstellt, da wir die Moduldatei std.ixx kompilieren.

  4. Importieren Sie die von Ihnen erstellte std-Bibliothek, indem Sie zunächst eine Datei namens importExample.cpp mit folgendem Inhalt erstellen:

    // requires /std:c++latest

import std;

int main()
{
    std::cout << "Import the STL library for best performance\n";
    std::vector<int> v{5, 5, 5};
    for (const auto& e : v)
    {
        std::cout << e;
    }
}

    Im vorherigen Code wird durch import std; die #include <vector> und #include <iostream> ersetzt. Die Anweisung import std; stellt alle Standardbibliotheken mit einer Anweisung zur Verfügung. Das Importieren der gesamten Standardbibliothek ist häufig viel schneller als die Verarbeitung einer einzelnen Standardbibliotheksheaderdatei wie beispielsweise #include <vector>.

  5. Kompilieren Sie das Beispiel mithilfe des folgenden Befehls im selben Verzeichnis wie im vorherigen Schritt:

    cl /c /std:c++latest /EHsc /nologo /W4 /reference "std=std.ifc" importExample.cpp
link importExample.obj std.obj

    In diesem Beispiel ist die Angabe /reference "std=std.ifc" in der Befehlszeile nicht notwendig, da der Compiler automatisch nach der .ifc-Datei sucht, die dem in der import-Anweisung angegebenen Modulnamen entspricht. Wenn der Compiler auf import std; stößt, kann er feststellen std.ifc, ob sie sich im gleichen Verzeichnis wie der Quellcode befindet. Wenn sich die .ifc-Datei in einem anderen Verzeichnis als der Quellcode befindet, verwenden Sie den /reference-Compilerschalter, um auf sie zu verweisen.

    In diesem Beispiel sind das Kompilieren des Quellcodes und das Verknüpfen der Implementierung des Moduls mit der Anwendung separate Schritte. Sie müssen nicht sein. Sie können cl /std:c++latest /EHsc /nologo /W4 /reference "std=std.ifc" importExample.cpp std.obj zum Kompilieren und Verknüpfen in einem Schritt verwenden. Es kann jedoch praktisch sein, separat zu erstellen und zu verknüpfen, da Sie dann nur einmal die Standardbibliothek namens Modul erstellen müssen, und dann können Sie in Ihrem Projekt oder aus mehreren Projekten im Verknüpfungsschritt Ihres Builds darauf verweisen.

    Wenn Sie ein einzelnes Projekt erstellen, können Sie die Schritte der Erstellung der std-Standardbibliothek namens Modul und den Schritt der Erstellung Ihrer Anwendung kombinieren, indem Sie in der Befehlszeile "%VCToolsInstallDir%\modules\std.ixx" hinzufügen. Platzieren Sie dies vor allen .cpp-Dateien, die das std-Modul nutzen.

    Der Name der ausführbaren Ausgabedatei stammt standardmäßig aus der ersten Eingabedatei. Verwenden Sie die /Fe-Compileroption, um den gewünschten Dateinamen der ausführbaren Datei anzugeben. In diesem Tutorial wird das Kompilieren des std benannten Moduls als separater Schritt gezeigt, da Sie nur einmal die Standardbibliothek namens Modul erstellen müssen, und sie können dann aus Ihrem Projekt oder aus mehreren Projekten darauf verweisen. Aber es kann praktisch sein, alles zusammen zu erstellen, wie in dieser Befehlszeile gezeigt:

    cl /FeimportExample /std:c++latest /EHsc /nologo /W4 "%VCToolsInstallDir%\modules\std.ixx" importExample.cpp

    Aufgrund der vorherigen Befehlszeile erzeugt der Compiler eine ausführbare Datei mit dem Namen importExample.exe. Wenn Sie diese ausführen, erhalten Sie die folgende Ausgabe:

    Import the STL library for best performance
555

Importieren der Standardbibliotheks- sowie der globalen C-Funktionen mit std.compat

Die C++-Standardbibliothek enthält die ISO C-Standardbibliothek. Das std.compat-Modul bietet alle Funktionen des std-Moduls wie std::vector, std::cout, std::printf, std::scanf usw. Aber es bietet auch die globalen Namenspaceversionen dieser Funktionen wie beispielsweise ::printf, ::scanf, ::fopen, ::size_t usw.

Das std.compat benannte Modul ist eine Kompatibilitätsschicht, welche die Migration von vorhandenem Code erleichtert, der auf C-Runtimefunktionen im globalen Namespace verweist. Wenn Sie das Hinzufügen von Namen zum globalen Namespace vermeiden möchten, verwenden Sie import std;. Wenn Sie die Migration einer Codebasis vereinfachen müssen, die viele nicht qualifizierte (globale Namespace) C-Runtimefunktionen verwendet, verwenden Sie import std.compat;. Dies stellt die globalen Namespace C-Runtimenamen bereit, damit Sie nicht alle globalen Namen markieren müssen mit std::. Wenn Sie keinen Code haben, der die globalen Namespace-C-Runtimefunktionen verwendet, müssen Sie import std.compat; nicht verwenden. Wenn Sie in Ihrem Code nur einige wenige C-Runtimefunktionen aufrufen, ist es vielleicht besser, import std; die wenigen globalen C-Runtimenamen, die es benötigen, mit std:: zu verwenden und zu markieren. Beispielsweise std::printf(). Wenn beim Kompilieren des Codes ein Fehler wie error C3861: 'printf': identifier not found angezeigt wird, ziehen Sie in Erwägung, import std.compat; zu verwenden, um die globalen Namespace C-Runtimefunktionen zu importieren.

Beispiel: Erstellen und Importieren von std.compat

Bevor Sie import std.compat; verwenden können, müssen Sie die Modulschnittstellendatei kompilieren, die Sie in Quellcodeform unter std.compat.ixx finden. Visual Studio liefert den Quellcode für das Modul mit, sodass Sie das Modul mit den für Ihr Projekt passenden Compilereinstellungen kompilieren können. Die Schritte sind ähnlich wie bei der Erstellung des std benannten Moduls. Das std benannte Modul wird zuerst erstellt, da std.compat davon abhängig ist:

  1. Öffnen Sie eine x86 Native Tools-Eingabeaufforderung für VS: Geben Sie im Windows-Startmenü x86 nativ ein und die Eingabeaufforderung sollte in der Liste der Anwendungen erscheinen. Stellen Sie sicher, dass die Eingabeaufforderung für Visual Studio 2022, Version 17.5 oder höher, ist. Wenn Sie die falsche Version der Eingabeaufforderung verwenden, erhalten Sie Compilerfehler.

  2. Erstellen Sie ein Verzeichnis, um dieses Beispiel zu testen wie beispielsweise %USERPROFILE%\source\repos\STLModules und machen Sie es zum aktuellen Verzeichnis. Wenn Sie ein Verzeichnis auswählen, auf das Sie keinen Schreibzugriff haben, erhalten Sie Fehlermeldungen.

  3. Kompilieren Sie die std und std.compat benannten Module mit dem folgenden Befehl:

    cl /std:c++latest /EHsc /nologo /W4 /c "%VCToolsInstallDir%\modules\std.ixx" "%VCToolsInstallDir%\modules\std.compat.ixx"

    Sie sollten std und std.compat kompilieren und dieselben Compilereinstellungen verwenden, die Sie auch für den Code verwenden wollen, der sie importieren soll. Wenn Sie eine Lösung mit mehreren Projekten haben, können Sie diese einmal kompilieren und dann mit der /reference-Compileroption von allen Projekten aus auf sie zugreifen.

    Wenn Fehler auftreten, stellen Sie sicher, dass Sie die richtige Version der Eingabeaufforderung verwenden.

    Der Compiler gibt vier Dateien aus den vorherigen beiden Schritten aus:

    • std.ifc ist die kompilierte binäre benannte Modulschnittstelle, die der Compiler zur Verarbeitung der import std;-Anweisung heranzieht. Der Compiler zieht auch std.ifc zur Verarbeitung von import std.compat; heran, da std.compat auf std erstellt/aufbaut. Dies ist ein Artefakt, das nur die Kompilierzeit betrifft. Es wird nicht mit Ihrer Anwendung ausgeliefert.
    • std.obj enthält die Implementierung der Standardbibliothek.
    • std.compat.ifc ist die kompilierte binäre benannte Modulschnittstelle, die der Compiler zur Verarbeitung der import std.compat;-Anweisung heranzieht. Dies ist ein Artefakt, das nur die Kompilierzeit betrifft. Es wird nicht mit Ihrer Anwendung ausgeliefert.
    • std.compat.obj enthält Implementierung. Die meisten Implementierungen werden jedoch von std.obj bereitgestellt. Fügen Sie std.obj der Befehlszeile hinzu, wenn Sie die Beispielanwendung kompilieren, um die Funktionen, die Sie aus der Standardbibliothek verwenden, statisch mit Ihrer Anwendung zu verknüpfen.

    Sie können den Objektdateinamen und den Namen der benannten Modulschnittstellendatei mit den folgenden Schaltern steuern:

    • /Fo legt den Namen der Objektdatei fest. Beispielsweise /Fo:"somethingelse". Standardmäßig verwendet der Compiler denselben Namen für die Objektdatei wie die Modulquelldatei (.ixx), die Sie kompilieren. Im Beispiel sind die Objektdateinamen std.obj und std.compat.obj standardmäßig, da wir die Moduldateien std.ixx und std.compat.obj kompilieren.
    • /ifcOutput legt den Namen der benannten Modulschnittstellendatei (.ifc) fest. Beispielsweise /ifcOutput "somethingelse.ifc". Standardmäßig verwendet der Compiler denselben Namen für die Modulschnittstellendatei (.ifc) wie die Modulquelldatei (.ixx), die Sie kompilieren. Im Beispiel sind die generierten ifc-Dateien standardmäßig std.ifc und std.compat.ifc, da wir die Moduldateien std.ixx und std.compat.ixx kompilieren.

  4. Importieren Sie die std.compat-Bibliothek, indem Sie zuerst eine Datei namens stdCompatExample.cpp mit dem folgenden Inhalt erstellen:

    import std.compat;

int main()
{
    printf("Import std.compat to get global names like printf()\n");

    std::vector<int> v{5, 5, 5};
    for (const auto& e : v)
    {
        printf("%i", e);
    }
}

    Im vorherigen Code wird durch import std.compat; die #include <cstdio> und #include <vector> ersetzt. Die Anweisung import std.compat; stellt die Standardbibliotheks- und C-Runtimefunktionen mit einer Anweisung zur Verfügung. Das Importieren dieses benannten Moduls, das die globalen Namespacefunktionen der C++-Standardbibliothek und C-Runtimebibliothek enthält, ist schneller als die Verarbeitung eines einzelnen #include wie #include <vector>.

  5. Kompilieren Sie das Beispiel mithilfe des folgenden Befehls:

    cl /std:c++latest /EHsc /nologo /W4 stdCompatExample.cpp
link stdCompatExample.obj std.obj std.compat.obj

    Wir mussten std.compat.ifc nicht in der Befehlszeile angeben, da der Compiler automatisch nach der .ifc-Datei sucht, die dem Modulnamen in einer import-Anweisung entspricht. Wenn der Compiler auf import std.compat; trifft, findet er std.compat.ifc, da wir ihn in dasselbe Verzeichnis wie den Quellcode geben, sodass wir ihn nicht in der Befehlszeile angeben müssen. Wenn sich die .ifc-Datei in einem anderen Verzeichnis als der Quellcode befindet oder einen anderen Namen hat, verwenden Sie den /reference-Compilerschalter, um auf sie zu verweisen.

    Wenn Sie std.compat importieren, müssen Sie eine Verknüpfung sowohl mit std.compat als auch mit std.obj herstellen, da std.compat den Code in std.obj verwendet.

    Wenn Sie ein einzelnes Projekt erstellen, können Sie die Schritte zum Erstellen der benannten Module std und std.compat der Standardbibliothek kombinieren, indem Sie "%VCToolsInstallDir%\modules\std.ixx" und "%VCToolsInstallDir%\modules\std.compat.ixx" der Befehlszeile (in dieser Reihenfolge) hinzufügen. In diesem Tutorial wird die Erstellung der Standardbibliotheksmodule als separater Schritt gezeigt, da Sie die Module der Standardbibliothek nur einmal erstellen müssen und dann von Ihrem Projekt oder von mehreren Projekten aus auf sie verweisen können. Wenn es jedoch praktisch ist, sie alle auf einmal zu erstellen, stellen Sie sicher, dass sie vor allen .cpp-Dateien stehen, die sie benötigen, und geben Sie /Fe an, um die erstellten exe, wie in diesem Beispiel gezeigt, zu benennen:

    cl /c /FestdCompatExample /std:c++latest /EHsc /nologo /W4 "%VCToolsInstallDir%\modules\std.ixx" "%VCToolsInstallDir%\modules\std.compat.ixx" stdCompatExample.cpp
link stdCompatExample.obj std.obj std.compat.obj

    In diesem Beispiel sind das Kompilieren des Quellcodes und das Verknüpfen der Implementierung des Moduls mit Ihrer Anwendung separate Schritte. Sie müssen nicht sein. Sie können cl /std:c++latest /EHsc /nologo /W4 stdCompatExample.cpp std.obj std.compat.obj zum Kompilieren und Verknüpfen in einem Schritt verwenden. Es kann jedoch sinnvoll sein, die Module separat zu erstellen und zu verknüpfen, da Sie dann die Module der Standardbibliothek nur einmal erstellen müssen und dann im Verknüpfungsschritt Ihres Builds auf sie in Ihrem Projekt oder in mehreren Projekten verweisen können.

    Der vorherige Compilerbefehl erzeugt eine ausführbare Datei mit dem Namen stdCompatExample.exe. Wenn Sie diese ausführen, erhalten Sie die folgende Ausgabe:

    Import std.compat to get global names like printf()
555

Überlegungen zu benannten Standardbibliotheken

Die Versionsverwaltung für benannte Module ist dieselbe wie für Header. Die .ixx genannten Moduldateien werden zusammen mit den Headern installiert, zum Beispiel: "%VCToolsInstallDir%\modules\std.ixx, dies entspricht der C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Tools\MSVC\14.38.33130\modules\std.ixx-Version der Tools, die zum Zeitpunkt der Erstellung dieses Artikels verwendet wurde. Wählen Sie die Version des benannten Moduls auf die gleiche Weise aus, wie Sie die Version der Headerdatei auswählen, die Sie verwenden möchten –durch das Verzeichnis, aus dem Sie darauf verweisen.

Vermischen und kombinieren Sie keine importierenden Headereinheiten und benannten Module. Führen Sie beispielsweise nicht import <vector>; und import std; in ein und derselben Datei aus.

Vermischen und kombinieren Sie keine importierenden C++-Standardbibliothek-Headerdateien sowie die benannten Module std oder std.compat. Führen Sie beispielsweise nicht #include <vector> und import std; in ein und derselben Datei aus. Sie können jedoch C-Header einschließen und benannte Module in derselben Datei importieren. Sie können beispielsweise import std; und #include <math.h> in derselben Datei ausführen. Fügen Sie einfach nicht die C++-Standardbibliotheksversion <cmath> ein.

Sie müssen sich nicht dagegen wehren, ein Modul mehrfach zu importieren. Das heißt, Sie benötigen keinen #ifndef-Formatvorlagen-Headerschutz in Modulen. Der Compiler weiß, wenn er ein benanntes Modul bereits importiert hat und ignoriert doppelte Versuche, dies zu tun.

Wenn Sie das assert()-Makro verwenden müssen, dann #include <assert.h>.

Wenn Sie das errno-Makro verwenden müssen, #include <errno.h>. Da benannte Module keine Makros verfügbar machen, ist dies die Umgehungslösung, wenn Sie beispielsweise nach Fehlern aus <math.h> suchen müssen.

Makros wie NAN, INFINITY und INT_MIN werden durch <limits.h> definiert, die Sie einbeziehen können. Wenn Sie jedoch import std;, können Sie numeric_limits<double>::quiet_NaN() und numeric_limits<double>::infinity() anstelle von NAN und INFINITY verwenden und std::numeric_limits<int>::min() anstelle von INT_MIN.

Zusammenfassung

In diesem Tutorial haben Sie die Standardbibliothek mithilfe von Modulen importiert. Erfahren Sie als Nächstes mehr über das Erstellen und Importieren eigener Module im Tutorial für benannte Module in C++.

Siehe auch

Vergleichen von Headereinheiten, Modulen und vorkompilierten Headern
Übersicht über Module in C++
Eine Tour durch C++-Module in Visual Studio
Verschieben eines Projekts in C++ benannte Module