C++ Standard Library headers

Die Schnittstelle der C++ Standardbibliothek ist durch die folgende Sammlung von Headern definiert.

Inhaltsverzeichnis 1 Mehrzweck-Header 2 Sprachunterstützungsbibliothek 3 Concepts-Bibliothek 4 Diagnosebibliothek 5 Speicherverwaltungsbibliothek 6 Metaprogrammierungsbibliothek 7 Allgemeine Hilfsbibliothek 8 Containerbibliothek 9 Iteratorenbibliothek 10 Ranges-Bibliothek 11 Algorithmenbibliothek 12 String-Bibliothek 13 Textverarbeitungsbibliothek 14 Numerikbibliothek 15 Zeitbibliothek 16 Eingabe/Ausgabe-Bibliothek 17 Nebenläufigkeitsunterstützungsbibliothek 18 C-Kompatibilitätsheader 18.1 Spezielle C-Kompatibilitätsheader 18.2 Leere C-Header 18.3 Bedeutungslose C-Header 18.4 Nicht unterstützte C-Header 19 Experimentelle Bibliotheken 20 Siehe auch Mehrzweck-Header
<cstdlib>	Allgemeine Hilfsprogramme: Programmsteuerung , dynamische Speicherverwaltung , Zufallszahlen , Sortieren und Suchen
<execution> (C++17)	Vordefinierte Ausführungsrichtlinien für parallele Versionen der Algorithmen und Ausführungssteuerungskomponenten (seit C++26)
Sprachunterstützungsbibliothek
<cfloat>	Grenzwerte der Gleitkommatypen
<climits>	Grenzwerte ganzzahliger Typen
<compare> (C++20)	Unterstützung für Three-way comparison operator
<contracts> (C++26)	Vertragsunterstützungsbibliothek
<coroutine> (C++20)	Coroutine-Unterstützungsbibliothek
<csetjmp>	Makro (und Funktion), das einen Ausführungskontext speichert (und zu diesem springt)
<csignal>	Funktionen und Makrokonstanten für Signalverwaltung
<cstdarg>	Behandlung von Argumentlisten variabler Länge
<cstddef>	Standardmakros und Typdefinitionen
<cstdint> (C++11)	Festbreiten-Ganzzahltypen und Grenzwerte anderer Typen
<exception>	Exception-Behandlungsfunktionen
<initializer_list> (C++11)	std::initializer_list Klassentemplate
<limits>	Abfrage von Eigenschaften arithmetischer Typen
<new>	Low-Level-Speicherverwaltungsfunktionen
<source_location> (C++20)	Bietet Mittel zum Abruf von Quellcode-Positionsinformationen
<stdfloat> (C++23)	Festbreiten-Gleitkommatypen
<typeindex> (C++11)	std::type_index
<typeinfo>	Laufzeit-Typinformationen-Dienstprogramme
<version> (C++20)	Stellt Makros zur Überprüfung des Implementierungsstatus der Bibliothek bereit
Concepts-Bibliothek
<concepts> (C++20)	Grundlegende Bibliothekskonzepte
Diagnosebibliothek
<cassert>	Bedingt kompilierte Makro, die ihr Argument mit Null vergleicht
<cerrno>	Makro, das die letzte Fehlernummer enthält
<debugging> (C++26)	Debugging-Bibliothek
<stacktrace> (C++23)	Stacktrace Bibliothek
<stdexcept>	Standardexceptionstypen
<system_error> (C++11)	Definiert std::error_code , einen plattformabhängigen Fehlercode
Speicherverwaltungsbibliothek
<memory>	Hochrangige Speicherverwaltungsfunktionen
<memory_resource> (C++17)	Polymorphe Allokatoren und Speicherressourcen
<scoped_allocator> (C++11)	Verschachtelte Allocator-Klasse
Metaprogrammierungsbibliothek
<ratio> (C++11)	Kompilierzeit-Rationalarithmetik
<type_traits> (C++11)	Dienstprogramme für Typinformationen zur Compile-Zeit
Bibliothek für allgemeine Hilfsmittel
<any> (C++17)	std::any Klasse
<bit> (C++20)	Bitmanipulationsfunktionen
<bitset>	std::bitset Klassentemplate
<expected> (C++23)	std::expected Klassentemplate
<functional>	Funktionsobjekte, Funktionsaufrufe, Bind-Operationen und Referenz-Wrapper
<optional> (C++17)	std::optional Klassentemplate
<tuple> (C++11)	std::tuple Klassentemplate
<utility>	Verschiedene Utility-Komponenten
<variant> (C++17)	std::variant Klassentemplate
Container-Bibliothek
<array> (C++11)	std::array Container
<deque>	std::deque Container
<flat_map> (C++23)	std::flat_map und std::flat_multimap Container-Adapter
<flat_set> (C++23)	std::flat_set und std::flat_multiset Container-Adapter
<forward_list> (C++11)	std::forward_list Container
<hive> (C++26)	std::hive Container
<inplace_vector> (C++26)	std::inplace_vector Container
<list>	std::list Container
<map>	std::map und std::multimap assoziative Container
<mdspan> (C++23)	std::mdspan Ansicht
<queue>	std::queue und std::priority_queue Container-Adapter
<set>	std::set und std::multiset assoziative Container
<span> (C++20)	std::span Ansicht
<stack>	std::stack Container-Adapter
<unordered_map> (C++11)	std::unordered_map und std::unordered_multimap ungeordnete assoziative Container
<unordered_set> (C++11)	std::unordered_set und std::unordered_multiset ungeordnete assoziative Container
<vector>	std::vector Container
Iteratoren-Bibliothek
<iterator>	Bereichs-Iteratoren
Ranges-Bibliothek
<generator> (C++23)	std::generator Klassentemplate
<ranges> (C++20)	Bereichszugriff, Primitive, Anforderungen, Hilfsmittel und Adapter
Algorithmenbibliothek
<algorithm>	Algorithmen, die auf Bereichen operieren
<numeric>	Numerische Operationen auf Werten in Bereichen
String-Bibliothek
<cstring>	Verschiedene Narrow-Character-String-Behandlungsfunktionen
<string>	std::basic_string Klassentemplate
<string_view> (C++17)	std::basic_string_view Klassentemplate
Textverarbeitungsbibliothek
<cctype>	Funktionen zur Bestimmung der Kategorie von Narrow Characters
<charconv> (C++17)	std::to_chars und std::from_chars
<clocale>	C-Lokalisierungsfunktionen
<codecvt> (C++11) (in C++17 veraltet) (in C++26 entfernt)	Unicode-Konvertierungsfunktionen
<cuchar> (C++11)	C-style Unicode-Zeichenkonvertierungsfunktionen
<cwchar>	Verschiedene Wide- und Multibyte- Zeichenketten-Behandlungsfunktionen
<cwctype>	Funktionen zur Bestimmung der Kategorie von Breitzeichen
<format> (C++20)	Formatierungsbibliothek einschließlich std::format
<locale>	Lokalisierungsfunktionen
<regex> (C++11)	Klassen, Algorithmen und Iteratoren zur Unterstützung der Verarbeitung regulärer Ausdrücke
<text_encoding> (C++26)	Textkodierungsidentifikationen
Numerik-Bibliothek
<cfenv> (C++11)	Gleitkomma-Umgebungsfunktionen Zugriffsfunktionen
<cmath>	Allgemeine mathematische Funktionen
<complex>	Komplexer Zahlentyp
<linalg> (C++26)	Grundlegende lineare Algebra Algorithmen (BLAS)
<numbers> (C++20)	Mathematische Konstanten
<random> (C++11)	Zufallszahlengeneratoren und Verteilungen
<simd> (C++26)	Datenparallele Typen und Operationen auf diesen Typen
<valarray>	Klasse zur Darstellung und Manipulation von Werte-Arrays
Zeitbibliothek
<chrono> (C++11)	C++ Zeit-Utilities
<ctime>	C-Stil Zeit-/Datumswerkzeuge
Input/Output-Bibliothek
<cinttypes> (C++11)	Formatierungsmakros , intmax_t und uintmax_t Mathematik und Konvertierungen
<cstdio>	C-Stil Eingabe-Ausgabe-Funktionen
<filesystem> (C++17)	std::filesystem::path Klasse und unterstützende Funktionen
<fstream>	std::basic_fstream , std::basic_ifstream , std::basic_ofstream Klassentemplates und Typdefinitionen
<iomanip>	Hilfsfunktionen zur Steuerung des Formats von Eingabe und Ausgabe
<ios>	std::ios_base Klasse, std::basic_ios Klassentemplate und Typdefinitionen
<iosfwd>	Vorwärtsdeklarationen aller Klassen in der Eingabe-/Ausgabebibliothek
<iostream>	Mehrere Standard-Stream-Objekte
<istream>	std::basic_istream Klassentemplate und Typdefinitionen
<ostream>	std::basic_ostream , std::basic_iostream Klassentemplates und Typdefinitionen
<print> (C++23)	Formatierte Ausgabebibliothek einschließlich std::print
<spanstream> (C++23)	std::basic_spanstream , std::basic_ispanstream , std::basic_ospanstream Klassentemplates und Typdefinitionen
<sstream>	std::basic_stringstream , std::basic_istringstream , std::basic_ostringstream Klassentemplates und Typdefinitionen
<streambuf>	std::basic_streambuf Klassentemplate
<strstream> (in C++98 veraltet) (in C++26 entfernt)	std::strstream , std::istrstream , std::ostrstream
<syncstream> (C++20)	std::basic_osyncstream , std::basic_syncbuf und Typdefinitionen
Concurrency Support Library
<atomic> (C++11)	Bibliothek für atomare Operationen
<barrier> (C++20)	Barrier
<condition_variable> (C++11)	Thread-Wartebedingungen
<future> (C++11)	Grundlagen für asynchrone Berechnungen
<hazard_pointer> (C++26)	Hazard-Pointer
<latch> (C++20)	Riegel
<mutex> (C++11)	Gegenseitige Ausschlussprimitive
<rcu> (C++26)	Read-Copy-Update-Mechanismen
<semaphore> (C++20)	Semaphoren
<shared_mutex> (C++14)	Gemeinsame gegenseitige Ausschlussprimitive
<stop_token> (C++20)	Stopp-Tokens für std::jthread
<thread> (C++11)	std::thread Klasse und unterstützende Funktionen

C-Kompatibilitätsheader

Für einige der C-Standardbibliotheksheader der Form xxx .h enthält die C++-Standardbibliothek sowohl einen gleichnamigen Header als auch einen weiteren Header der Form c xxx (alle relevanten c xxx -Header sind oben aufgeführt). Die vorgesehene Verwendung von Headern der Form xxx .h dient ausschließlich der Interoperabilität. Es ist möglich, dass C++-Quelldateien einen dieser Header einbinden müssen, um valides ISO C zu sein. Quelldateien, die nicht gleichzeitig valides ISO C sein sollen, sollten keine der C-Header verwenden.

Mit Ausnahme von complex.h platziert jeder xxx .h -Header, der in der C++-Standardbibliothek enthalten ist, jeden Namen im globalen Namensraum, den der entsprechende c xxx -Header im std -Namensraum platziert hätte.

Diese Header dürfen dieselben Namen auch im std -Namespace deklarieren, und die entsprechenden c xxx -Header dürfen dieselben Namen auch im globalen Namespace deklarieren: Das Inkludieren von <cstdlib> stellt definitiv std::malloc bereit und kann auch :: malloc bereitstellen. Das Inkludieren von <stdlib.h> stellt definitiv :: malloc bereit und kann auch std::malloc bereitstellen. Dies gilt sogar für Funktionen und Funktionsüberladungen, die nicht Teil der C-Standardbibliothek sind.

Hinweise: xxx .h Header sind in C++98 als veraltet markiert und in C++23 wieder als nicht veraltet eingestuft. Diese Header werden für reinen C++-Code nicht empfohlen, sind jedoch nicht von zukünftiger Entfernung betroffen.

<assert.h>	Verhält sich gleich wie <cassert>
<ctype.h>	Verhält sich so, als ob jeder Name aus <cctype> im globalen Namensraum platziert wird
<errno.h>	Verhält sich gleich wie <cerrno>
<fenv.h> (C++11)	Verhält sich so, als ob jeder Name aus <cfenv> im globalen Namensraum platziert wird
<float.h>	Verhält sich gleich wie <cfloat>
<inttypes.h> (C++11)	Verhält sich so, als ob jeder Name aus <cinttypes> im globalen Namensraum platziert wird
<limits.h>	Verhält sich gleich wie <climits>
<locale.h>	Verhält sich so, als ob jeder Name aus <clocale> im globalen Namensraum platziert wird
<math.h>	Verhält sich so, als ob jeder Name aus <cmath> im globalen Namensraum platziert wird, außer den Namen der mathematischen Sonderfunktionen
<setjmp.h>	Verhält sich so, als ob jeder Name aus <csetjmp> im globalen Namensraum platziert wird
<signal.h>	Verhält sich so, als ob jeder Name aus <csignal> im globalen Namensraum platziert wird
<stdarg.h>	Verhält sich so, als ob jeder Name aus <cstdarg> im globalen Namensraum platziert wird
<stddef.h>	Verhält sich so, als ob jeder Name aus <cstddef> im globalen Namensraum platziert wird, außer den Namen von std::byte und zugehörigen Funktionen
<stdint.h> (C++11)	Verhält sich so, als ob jeder Name aus <cstdint> im globalen Namensraum platziert wird
<stdio.h>	Verhält sich so, als ob jeder Name aus <cstdio> im globalen Namensraum platziert wird
<stdlib.h>	Verhält sich so, als ob jeder Name aus <cstdlib> im globalen Namensraum platziert wird
<string.h>	Verhält sich so, als ob jeder Name aus <cstring> im globalen Namensraum platziert wird
<time.h>	Verhält sich so, als ob jeder Name aus <ctime> im globalen Namensraum platziert wird
<uchar.h> (C++11)	Verhält sich so, als ob jeder Name aus <cuchar> im globalen Namensraum platziert wird
<wchar.h>	Verhält sich so, als ob jeder Name aus <cwchar> im globalen Namensraum platziert wird
<wctype.h>	Verhält sich so, als ob jeder Name aus <cwctype> im globalen Namensraum platziert wird

Spezielle C-Kompatibilitätsheader

Die Header <stdatomic.h> , <stdbit.h> und <stdckdint.h> deklarieren Namen, die ebenfalls in der C-Standardbibliothek bereitgestellt werden. Der Header <stdatomic.h> definiert auch das _Atomic Makro, welches ein Schlüsselwort in C ist. Im Gegensatz zu anderen < xxx .h> Headern werden entsprechende <cstdatomic> , <cstdbit> und <cstdckdint> nicht bereitgestellt.

<stdatomic.h> (C++23)	Definiert _Atomic und stellt entsprechende Komponenten der C-Standardbibliothek bereit
<stdbit.h> (C++26)	Stellt entsprechende Komponenten der C-Standardbibliothek bereit
<stdckdint.h> (C++26)	Stellt entsprechende Komponenten der C-Standardbibliothek bereit

Leere C-Header

Die Header <complex.h> , <ccomplex> , <tgmath.h> und <ctgmath> enthalten keine Inhalte aus der C-Standardbibliothek, sondern binden lediglich andere Header aus der C++-Standardbibliothek ein.

<ccomplex> (C++11) (veraltet in C++17) (entfernt in C++20)	Enthält lediglich den Header <complex>
<complex.h> (C++11)	Enthält lediglich den Header <complex>
<ctgmath> (C++11) (veraltet in C++17) (entfernt in C++20)	Enthält lediglich die Header <complex> und <cmath> : Die Überladungen, die den Inhalten des C-Headers <tgmath.h> entsprechen, werden bereits von diesen Headern bereitgestellt
<tgmath.h> (C++11)	Enthält lediglich die Header <complex> und <cmath>

Bedeutungslose C-Header

Die Header <ciso646> , <cstdalign> und <cstdbool> sind in C++ bedeutungslos, da die Makros, die sie in C bereitstellen, in C++ Sprachschlüsselwörter sind.

<ciso646> (entfernt in C++20)	Leerer Header. Die Makros, die in iso646.h in C erscheinen sind Schlüsselwörter in C++
<cstdalign> (C++11) (veraltet in C++17) (entfernt in C++20)	Definiert Kompatibilitätsmakrokonstanten __alignas_is_defined und __alignof_is_defined
<cstdbool> (C++11) (veraltet in C++17) (entfernt in C++20)	Definiert eine Kompatibilitätsmakrokonstante __bool_true_false_are_defined
<iso646.h>	Hat keine Wirkung
<stdalign.h> (C++11)	Definiert Kompatibilitätsmakrokonstanten __alignas_is_defined und __alignof_is_defined
<stdbool.h> (C++11)	Definiert eine Kompatibilitätsmakrokonstante __bool_true_false_are_defined

Nicht unterstützte C-Header

Die C-Header <stdatomic.h> , (bis C++23) <stdnoreturn.h> und <threads.h> sind in C++ nicht enthalten und haben keine c xxx Äquivalente.

Experimentelle Bibliotheken

C++ TR's/TS's definieren ebenfalls mehrere Sammlungen von Headern.

Siehe auch

C-Dokumentation für Standardbibliothek-Header