Samouczek: importowanie standardowej biblioteki języka C++ przy użyciu modułów z wiersza polecenia

Artykuł
01/30/2024

Dowiedz się, jak zaimportować standardową bibliotekę języka C++ przy użyciu modułów biblioteki języka C++. Skutkuje to szybszą kompilacją i jest bardziej niezawodne niż używanie plików nagłówków lub jednostek nagłówków lub wstępnie skompilowanych nagłówków (PCH).

Z tego samouczka dowiesz się więcej o następujących tematach:

Jak zaimportować bibliotekę standardową jako moduł z wiersza polecenia.
Zalety wydajności i użyteczności modułów.
Dwa standardowe moduły std biblioteki i std.compat różnica między nimi.

Wymagania wstępne

Ten samouczek wymaga programu Visual Studio 2022 w wersji 17.5 lub nowszej.

Wprowadzenie do modułów biblioteki standardowej

Pliki nagłówków mają wpływ na semantyki, które mogą się zmieniać w zależności od definicji makr, kolejności, w której je uwzględniono, i są one powolne kompilacji. Moduły rozwiązują te problemy.

Teraz można zaimportować bibliotekę standardową jako moduł zamiast jako splątanie plików nagłówkowych. Jest to znacznie szybsze i bardziej niezawodne niż dołączanie plików nagłówków lub jednostek nagłówków lub wstępnie skompilowanych nagłówków (PCH).

W standardowej bibliotece języka C++23 wprowadzono dwa nazwane moduły: std i std.compat:

std eksportuje deklaracje i nazwy zdefiniowane w standardowej przestrzeni nazw stdbiblioteki języka C++, na przykład std::vector. Eksportuje również zawartość nagłówków otoki języka C, takich jak i <cstdlib>, które udostępniają funkcje takie jak <cstdio> std::printf(). Funkcje języka C zdefiniowane w globalnej przestrzeni nazw, takie jak ::printf(), nie są eksportowane. Poprawia to sytuację, w której dołączanie nagłówka otoki języka C, takie jak <cstdio>również pliki nagłówków języka C, takie jak stdio.h, co powoduje wprowadzenie globalnych wersji przestrzeni nazw języka C. Nie jest to problem podczas importowania stdpliku .
std.compat eksportuje wszystkie elementy i std dodaje globalne przestrzenie nazw środowiska uruchomieniowego języka C, takie jak ::printf, ::fopen, ::size_t, i ::strlentak dalej. Moduł std.compat ułatwia pracę z bazami kodu odwołującymi się do wielu funkcji/typów środowiska uruchomieniowego języka C w globalnej przestrzeni nazw.

Kompilator importuje całą bibliotekę standardową podczas korzystania import std; z biblioteki lub import std.compat; wykonuje ją szybciej niż wprowadzanie pojedynczego pliku nagłówka. Szybsze jest wprowadzenie całej standardowej biblioteki import std; (lub import std.compat) niż do #include <vector>, na przykład.

Ponieważ nazwane moduły nie ujawniają makr, makra, takie jak , , , i inne, nie są dostępne podczas importowania std lub std.compat. va_argoffsetoferrnoassert Aby uzyskać obejścia, zobacz Kwestie dotyczące biblioteki standardowej o nazwie modułu.

Informacje o modułach języka C++

Pliki nagłówkowe to sposób udostępniania deklaracji i definicji między plikami źródłowymi w języku C++. Przed modułami biblioteki standardowej należy uwzględnić część biblioteki standardowej, której potrzebujesz z dyrektywą, na przykład #include <vector>. Pliki nagłówków są kruche i trudne do skomponowania, ponieważ ich semantyka może ulec zmianie w zależności od kolejności, w której je uwzględniono, lub czy niektóre makra są zdefiniowane. Spowalniają również kompilację, ponieważ są one ponownie przetwarzane przez każdy plik źródłowy, który je zawiera.

Język C++20 wprowadza nowoczesną alternatywę nazywaną modułami. W języku C++23 mogliśmy wykorzystać obsługę modułów w celu wprowadzenia nazwanych modułów do reprezentowania standardowej biblioteki.

Podobnie jak pliki nagłówkowe, moduły umożliwiają udostępnianie deklaracji i definicji między plikami źródłowymi. Jednak w przeciwieństwie do plików nagłówkowych moduły nie są kruche i są łatwiejsze do skomponowania, ponieważ ich semantyka nie zmienia się ze względu na definicje makr ani kolejność ich importowania. Kompilator może przetwarzać moduły znacznie szybciej niż może przetwarzać #include pliki i używa mniej pamięci w czasie kompilacji. Nazwane moduły nie uwidaczniają definicji makr ani szczegółów implementacji prywatnej.

Aby uzyskać szczegółowe informacje na temat modułów, zobacz Omówienie modułów w języku C++ W tym artykule omówiono również używanie standardowej biblioteki języka C++ jako modułów, ale używa starszego i eksperymentalnego sposobu jego wykonywania.

W tym artykule przedstawiono nowy i najlepszy sposób korzystania ze standardowej biblioteki. Aby uzyskać więcej informacji na temat alternatywnych sposobów korzystania z biblioteki standardowej, zobacz Porównanie jednostek nagłówka, modułów i wstępnie skompilowanych nagłówków.

Importowanie standardowej biblioteki za pomocą polecenia `std`

W poniższych przykładach pokazano, jak używać standardowej biblioteki jako modułu przy użyciu kompilatora wiersza polecenia. Aby uzyskać informacje o tym, jak to zrobić w środowisku IDE programu Visual Studio, zobacz Build ISO C++23 Standard Library Modules (Kompilowanie modułów biblioteki standardowej ISO C++23).

import std; Instrukcja lub import std.compat; importuje bibliotekę standardową do aplikacji. Najpierw należy jednak skompilować bibliotekę standardową o nazwie modules w postaci binarnej. W poniższych krokach pokazano, jak to zrobić.

Przykład: Jak skompilować i zaimportować `std`

Otwórz wiersz polecenia narzędzi natywnych x86 dla programu VS: z menu Start systemu Windows wpisz x86 native, a monit powinien pojawić się na liście aplikacji. Upewnij się, że monit dotyczy programu Visual Studio 2022 w wersji 17.5 lub nowszej. Jeśli używasz nieprawidłowej wersji monitu, wystąpią błędy. Przykłady używane w tym samouczku dotyczą powłoki CMD.
Utwórz katalog, taki jak %USERPROFILE%\source\repos\STLModules, i ustaw go jako bieżący katalog. Jeśli wybierzesz katalog, do którego nie masz dostępu do zapisu, podczas kompilacji wystąpią błędy.

Skompiluj nazwany std moduł za pomocą następującego polecenia:

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

Jeśli wystąpią błędy, upewnij się, że używasz poprawnej wersji wiersza polecenia.

Skompiluj std nazwany moduł przy użyciu tych samych ustawień kompilatora, które mają być używane z kodem, który importuje skompilowany moduł. Jeśli masz rozwiązanie wieloprojektowe, możesz skompilować bibliotekę standardową o nazwie module raz, a następnie odwołać się do niej ze wszystkich projektów przy użyciu opcji kompilatora /reference .

Za pomocą poprzedniego polecenia kompilatora kompilator zwraca dwa pliki:

std.ifc to skompilowana binarna reprezentacja nazwanego interfejsu modułu, z którym kompilator skonsultuje się w celu przetworzenia instrukcji import std; . Jest to artefakt tylko w czasie kompilacji. Nie jest ona dostarczana z aplikacją.
std.obj zawiera implementację nazwanego modułu. Dodaj std.obj do wiersza polecenia podczas kompilowania przykładowej aplikacji, aby statycznie połączyć funkcje używane z biblioteki standardowej do aplikacji.

Kluczowe przełączniki wiersza polecenia w tym przykładzie to:

Przełącznik	Znaczenie
`/std:c++:latest`	Użyj najnowszej wersji standardu języka C++ i biblioteki. Mimo że obsługa modułów jest dostępna w obszarze `/std:c++20`, potrzebujesz najnowszej standardowej biblioteki, aby uzyskać obsługę standardowej biblioteki o nazwie modules.
`/EHsc`	Użyj obsługi wyjątków języka C++, z wyjątkiem funkcji oznaczonych jako `extern "C"`.
`/W4`	Użycie /W4 jest ogólnie zalecane, szczególnie w przypadku nowych projektów, ponieważ włącza wszystkie poziom 1, poziom 2, poziom 3 i większość ostrzeżeń poziomu 4 (informacyjnego), co może pomóc w wczesnym przechwytywaniu potencjalnych problemów. Zasadniczo zapewnia ostrzeżenia podobne do lint, które mogą pomóc zapewnić najmniejsze możliwe trudne do znalezienia wady kodu.
`/c`	Kompiluj bez łączenia, ponieważ w tym momencie kompilujemy tylko interfejs binarny o nazwie module.

Nazwę pliku obiektu i nazwę pliku interfejsu modułu można kontrolować za pomocą następujących przełączników:

/Fo ustawia nazwę pliku obiektu. Na przykład /Fo:"somethingelse". Domyślnie kompilator używa tej samej nazwy pliku obiektu co plik źródłowy modułu (.ixx), który kompilujesz. W tym przykładzie nazwa pliku obiektu jest std.obj domyślnie, ponieważ kompilujemy plik std.ixxmodułu .
/ifcOutput Ustawia nazwę nazwanego pliku interfejsu modułu (.ifc). Na przykład /ifcOutput "somethingelse.ifc". Domyślnie kompilator używa tej samej nazwy dla pliku interfejsu modułu (.ifc) co plik źródłowy modułu (.ixx) kompilowany. W tym przykładzie wygenerowany ifc plik jest std.ifc domyślnie tworzony, ponieważ kompilujemy plik std.ixxmodułu .

Zaimportuj utworzoną bibliotekę std , tworząc najpierw plik o nazwie importExample.cpp o następującej zawartości:
```
// 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;
    }
}
```
W poprzednim kodzie import std; zastępuje wartości #include <vector> i #include <iostream>. import std; Instrukcja udostępnia całą bibliotekę standardową za pomocą jednej instrukcji. Importowanie całej standardowej biblioteki jest często znacznie szybsze niż przetwarzanie pojedynczego standardowego pliku nagłówka biblioteki, takiego jak #include <vector>.
Skompiluj przykład przy użyciu następującego polecenia w tym samym katalogu co poprzedni krok:
```
cl /c /std:c++latest /EHsc /nologo /W4 /reference "std=std.ifc" importExample.cpp
link importExample.obj std.obj
```
Nie jest konieczne określenie /reference "std=std.ifc" w wierszu polecenia w tym przykładzie, ponieważ kompilator automatycznie wyszukuje .ifc plik pasujący do nazwy modułu określonej przez instrukcję import . Gdy kompilator napotka import std; , może znaleźć std.ifc , czy znajduje się w tym samym katalogu co kod źródłowy. .ifc Jeśli plik znajduje się w innym katalogu niż kod źródłowy, użyj przełącznika kompilatora/reference, aby się do niego odwoływać.

W tym przykładzie kompilowanie kodu źródłowego i łączenie implementacji modułu z aplikacją są oddzielnymi krokami. Nie muszą być. Możesz użyć cl /std:c++latest /EHsc /nologo /W4 /reference "std=std.ifc" importExample.cpp std.obj polecenia , aby skompilować i połączyć w jednym kroku. Jednak może być wygodne kompilowanie i łączenie oddzielnie, ponieważ wystarczy utworzyć bibliotekę standardową o nazwie module raz, a następnie odwołać się do niej z projektu lub z wielu projektów w kroku linku kompilacji.

Jeśli tworzysz pojedynczy projekt, możesz połączyć kroki kompilowania standardowej std biblioteki o nazwie module i kroku kompilowania aplikacji przez dodanie "%VCToolsInstallDir%\modules\std.ixx" do wiersza polecenia. Umieść go przed wszystkimi .cpp plikami korzystającymi z modułu std .

Domyślnie nazwa wyjściowego pliku wykonywalnego jest pobierana z pierwszego pliku wejściowego. Użyj opcji kompilatora /Fe , aby określić odpowiednią nazwę pliku wykonywalnego. W tym samouczku pokazano kompilowanie nazwanego modułu std jako oddzielnego kroku, ponieważ wystarczy utworzyć bibliotekę standardową o nazwie module raz, a następnie odwołać się do niego z projektu lub z wielu projektów. Ale może być wygodne, aby utworzyć wszystko razem, jak pokazano w tym wierszu polecenia:
```
cl /FeimportExample /std:c++latest /EHsc /nologo /W4 "%VCToolsInstallDir%\modules\std.ixx" importExample.cpp
```
Biorąc pod uwagę poprzedni wiersz polecenia, kompilator tworzy plik wykonywalny o nazwie importExample.exe. Po uruchomieniu generuje następujące dane wyjściowe:
```
Import the STL library for best performance
555
```

Importowanie standardowej biblioteki i globalnych funkcji języka C za pomocą polecenia `std.compat`

Standardowa biblioteka języka C++ zawiera standardową bibliotekę ISO C. Moduł std.compat udostępnia wszystkie funkcje modułu std , takie jak std::vector, std::cout, std::printf, std::scanfi tak dalej. Udostępnia również globalne wersje tych funkcji, takie jak ::printf, ::scanf, ::fopen, ::size_ti tak dalej.

Nazwany std.compat moduł to warstwa zgodności udostępniona w celu ułatwienia migracji istniejącego kodu, który odwołuje się do funkcji środowiska uruchomieniowego języka C w globalnej przestrzeni nazw. Jeśli chcesz uniknąć dodawania nazw do globalnej przestrzeni nazw, użyj polecenia import std;. Jeśli chcesz ułatwić migrację bazy kodu korzystającej z wielu niekwalifikowanych (globalnych funkcji środowiska uruchomieniowego przestrzeni nazw) języka C, użyj polecenia import std.compat;. Zapewnia to globalne nazwy środowiska uruchomieniowego C przestrzeni nazw, dzięki czemu nie trzeba kwalifikować wszystkich nazw globalnych za pomocą std::polecenia . Jeśli nie masz żadnego istniejącego kodu korzystającego z globalnych funkcji środowiska uruchomieniowego C przestrzeni nazw, nie musisz używać polecenia import std.compat;. Jeśli wywołasz tylko kilka funkcji środowiska uruchomieniowego języka C w kodzie, lepszym rozwiązaniem może być użycie import std; i zakwalifikowanie kilku globalnych nazw środowiska uruchomieniowego języka C, które ich potrzebują za pomocą std::polecenia . Na przykład std::printf(). Jeśli podczas próby skompilowania kodu zostanie wyświetlony błąd error C3861: 'printf': identifier not found , rozważ użycie polecenia import std.compat; w celu zaimportowania globalnych funkcji środowiska uruchomieniowego języka C przestrzeni nazw.

Przykład: Jak skompilować i zaimportować `std.compat`

Aby można było użyć import std.compat; polecenia, należy skompilować plik interfejsu modułu znajdujący się w formularzu kodu źródłowego w pliku std.compat.ixx. Program Visual Studio dostarcza kod źródłowy modułu, aby można było skompilować moduł przy użyciu ustawień kompilatora pasujących do projektu. Kroki są podobne do tworzenia nazwanego modułu std . Nazwany std moduł jest tworzony jako pierwszy, ponieważ std.compat zależy od niego:

Otwórz wiersz polecenia narzędzi natywnych dla programu VS: z menu Start systemu Windows wpisz ciąg natywny x86, a monit powinien pojawić się na liście aplikacji. Upewnij się, że monit dotyczy programu Visual Studio 2022 w wersji 17.5 lub nowszej. Jeśli używasz nieprawidłowej wersji monitu, wystąpią błędy kompilatora.
Utwórz katalog, aby wypróbować ten przykład, taki jak %USERPROFILE%\source\repos\STLModules, i ustaw go jako bieżący katalog. Jeśli wybierzesz katalog, do którego nie masz dostępu do zapisu, wystąpią błędy.
Skompiluj std moduły i std.compat nazwane za pomocą następującego polecenia:
```
cl /std:c++latest /EHsc /nologo /W4 /c "%VCToolsInstallDir%\modules\std.ixx" "%VCToolsInstallDir%\modules\std.compat.ixx"
```
Należy skompilować std i std.compat użyć tych samych ustawień kompilatora, które mają być używane z kodem, który je zaimportuje. Jeśli masz rozwiązanie wieloprojektowe, możesz je skompilować raz, a następnie odwołać się do nich ze wszystkich projektów przy użyciu opcji kompilatora /reference .

Jeśli wystąpią błędy, upewnij się, że używasz poprawnej wersji wiersza polecenia.

Kompilator zwraca cztery pliki z poprzednich dwóch kroków:
- std.ifc to skompilowany binarny interfejs o nazwie module, z którym kompilator skonsultuje się w celu przetworzenia instrukcji import std; . Kompilator skonsultuje std.ifc się również z procesemimport std.compat;, ponieważ std.compat opiera się na .std Jest to artefakt tylko w czasie kompilacji. Nie jest ona dostarczana z aplikacją.
- std.obj zawiera implementację standardowej biblioteki.
- std.compat.ifc to skompilowany binarny interfejs o nazwie module, z którym kompilator skonsultuje się w celu przetworzenia instrukcji import std.compat; . Jest to artefakt tylko w czasie kompilacji. Nie jest ona dostarczana z aplikacją.
- std.compat.obj zawiera implementację. Jednak większość implementacji jest dostarczana przez std.objprogram . Dodaj std.obj do wiersza polecenia podczas kompilowania przykładowej aplikacji, aby statycznie połączyć funkcje używane z biblioteki standardowej do aplikacji.
Nazwę pliku obiektu i nazwę pliku interfejsu modułu można kontrolować za pomocą następujących przełączników:
- /Fo ustawia nazwę pliku obiektu. Na przykład /Fo:"somethingelse". Domyślnie kompilator używa tej samej nazwy pliku obiektu co plik źródłowy modułu (.ixx), który kompilujesz. W tym przykładzie nazwy plików obiektów są std.obj i std.compat.obj domyślnie, ponieważ kompilujemy pliki std.ixx modułu i std.compat.obj.
- /ifcOutput Ustawia nazwę nazwanego pliku interfejsu modułu (.ifc). Na przykład /ifcOutput "somethingelse.ifc". Domyślnie kompilator używa tej samej nazwy dla pliku interfejsu modułu (.ifc) co plik źródłowy modułu (.ixx) kompilowany. W tym przykładzie wygenerowane ifc pliki są std.ifc domyślnie tworzone, std.compat.ifc ponieważ kompilujemy pliki std.ixx modułu i std.compat.ixx.
Zaimportuj bibliotekę std.compat , tworząc najpierw plik o nazwie stdCompatExample.cpp o następującej zawartości:
```
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);
    }
}
```
W poprzednim kodzie import std.compat; zastępuje wartości #include <cstdio> i #include <vector>. import std.compat; Instrukcja udostępnia standardowe funkcje biblioteki i środowiska uruchomieniowego języka C za pomocą jednej instrukcji. Importowanie tego nazwanego modułu, który obejmuje standardową bibliotekę języka C++ i globalne funkcje przestrzeni nazw biblioteki środowiska uruchomieniowego języka C, jest szybsze niż przetwarzanie pojedynczego, takiego #include jak #include <vector>.
Skompiluj przykład przy użyciu następującego polecenia:
```
cl /std:c++latest /EHsc /nologo /W4 stdCompatExample.cpp
link stdCompatExample.obj std.obj std.compat.obj
```
Nie musieliśmy określać std.compat.ifc w wierszu polecenia, ponieważ kompilator automatycznie wyszukuje .ifc plik zgodny z nazwą modułu w instrukcji import . Gdy kompilator napotka import std.compat; go std.compat.ifc , ponieważ umieścimy go w tym samym katalogu co kod źródłowy — zwalnia nas z konieczności określenia go w wierszu polecenia. .ifc Jeśli plik znajduje się w innym katalogu niż kod źródłowy lub ma inną nazwę, użyj przełącznika kompilatora/reference, aby się do niego odwoływać.

Podczas importowania std.compatelementu należy połączyć się z parametrami i std.compat std.obj , ponieważ std.compat używa kodu w elemecie std.obj.

Jeśli tworzysz pojedynczy projekt, możesz połączyć kroki kompilowania std standardowej biblioteki o std.compat nazwie modules, dodając "%VCToolsInstallDir%\modules\std.ixx" i "%VCToolsInstallDir%\modules\std.compat.ixx" (w tej kolejności) do wiersza polecenia. W tym samouczku przedstawiono tworzenie modułów biblioteki standardowej jako osobny krok, ponieważ wystarczy utworzyć bibliotekę standardową o nazwie modules raz, a następnie odwołać się do nich z projektu lub z wielu projektów. Jeśli jednak kompilowanie wszystkich jest wygodne, pamiętaj, aby umieścić je przed wszystkimi .cpp plikami, które z nich korzystają, i określić /Fe nazwę skompilowana exe , jak pokazano w tym przykładzie:
```
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
```
W tym przykładzie kompilowanie kodu źródłowego i łączenie implementacji modułu z aplikacją są oddzielnymi krokami. Nie muszą być. Możesz użyć cl /std:c++latest /EHsc /nologo /W4 stdCompatExample.cpp std.obj std.compat.obj polecenia , aby skompilować i połączyć w jednym kroku. Jednak tworzenie i łączenie osobno może być wygodne, ponieważ wystarczy utworzyć bibliotekę standardową o nazwie modules raz, a następnie odwołać się do nich z projektu lub z wielu projektów w kroku linku kompilacji.

Poprzednie polecenie kompilatora generuje plik wykonywalny o nazwie stdCompatExample.exe. Po uruchomieniu generuje następujące dane wyjściowe:
```
Import std.compat to get global names like printf()
555
```

Zagadnienia dotyczące biblioteki standardowej o nazwie module

Przechowywanie wersji dla nazwanych modułów jest takie samo jak w przypadku nagłówków. Pliki .ixx nazwanych modułów są instalowane wraz z nagłówkami, na przykład: "%VCToolsInstallDir%\modules\std.ixx, który jest rozpoznawany C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Tools\MSVC\14.38.33130\modules\std.ixx w wersji narzędzi używanych w momencie pisania tego tekstu. Wybierz wersję nazwanego modułu w taki sam sposób, jak w przypadku wybrania wersji pliku nagłówka do użycia — przez katalog, z którego się odwołujesz.

Nie mieszaj i nie dopasuj do importowania jednostek nagłówka i nazwanych modułów. Na przykład nie import <vector>; i import std; w tym samym pliku.

Nie mieszaj ani nie dopasuj do importowania standardowych plików nagłówków biblioteki języka C++ oraz nazwanych modułów std lub std.compat. Na przykład nie #include <vector> i import std; w tym samym pliku. Można jednak uwzględnić nagłówki języka C i zaimportować nazwane moduły w tym samym pliku. Na przykład możesz import std; i #include <math.h> w tym samym pliku. Po prostu nie dołączaj standardowej wersji <cmath>biblioteki języka C++ .

Nie musisz wielokrotnie bronić się przed importowaniem modułu. Oznacza to, że w modułach nie są potrzebne #ifndef osłony nagłówków stylów. Kompilator wie, kiedy zaimportował już nazwany moduł i ignoruje zduplikowane próby wykonania tej czynności.

Jeśli musisz użyć makra assert() , to #include <assert.h>.

Jeśli musisz użyć makra errno , #include <errno.h>. Ponieważ nazwane moduły nie uwidaczniają makr, jest to obejście, jeśli na przykład należy sprawdzić błędy z <math.h>programu .

Makra, takie jak NAN, INFINITYi INT_MIN , są definiowane przez <limits.h>parametr , które można uwzględnić. Jeśli jednak możesz import std; użyć poleceń numeric_limits<double>::quiet_NaN() i numeric_limits<double>::infinity() zamiast NAN i INFINITY, i std::numeric_limits<int>::min() zamiast INT_MIN.

Podsumowanie

W tym samouczku zaimportowaliśmy bibliotekę standardową przy użyciu modułów. Następnie dowiedz się więcej o tworzeniu i importowaniu własnych modułów w samouczku Nazwane moduły w języku C++.

Zobacz też

Porównanie jednostek nagłówka, modułów i wstępnie skompilowanych nagłówków
Omówienie modułów w języku C++
Przewodnik po modułach języka C++ w programie Visual Studio
Przenoszenie projektu do języka C++ o nazwie Modules

Udostępnij za pośrednictwem

Samouczek: importowanie standardowej biblioteki języka C++ przy użyciu modułów z wiersza polecenia

Wymagania wstępne

Wprowadzenie do modułów biblioteki standardowej

Informacje o modułach języka C++

Importowanie standardowej biblioteki za pomocą polecenia `std`

Przykład: Jak skompilować i zaimportować `std`

Importowanie standardowej biblioteki i globalnych funkcji języka C za pomocą polecenia `std.compat`

Przykład: Jak skompilować i zaimportować `std.compat`

Zagadnienia dotyczące biblioteki standardowej o nazwie module

Podsumowanie

Zobacz też

Opinia

Dodatkowe zasoby

Udostępnij za pośrednictwem

Samouczek: importowanie standardowej biblioteki języka C++ przy użyciu modułów z wiersza polecenia

Wymagania wstępne

Wprowadzenie do modułów biblioteki standardowej

Informacje o modułach języka C++

Importowanie standardowej biblioteki za pomocą polecenia std

Przykład: Jak skompilować i zaimportować std

Importowanie standardowej biblioteki i globalnych funkcji języka C za pomocą polecenia std.compat

Przykład: Jak skompilować i zaimportować std.compat

Zagadnienia dotyczące biblioteki standardowej o nazwie module

Podsumowanie

Zobacz też

Opinia

Dodatkowe zasoby

Importowanie standardowej biblioteki za pomocą polecenia `std`

Przykład: Jak skompilować i zaimportować `std`

Importowanie standardowej biblioteki i globalnych funkcji języka C za pomocą polecenia `std.compat`

Przykład: Jak skompilować i zaimportować `std.compat`