View source for cpp/standard library

You do not have permission to edit this page, for the following reasons:
The action you have requested is limited to users in one of the groups: Users, Administrators.
Due to recent vandalism, editing of this page is temporarily disabled for new users.If you want to suggest a change, please leave a message on the suggestions page for new users instead (don't be surprised if that page appears vandalized!).
You can view and copy the source of this page.
{{title|C++ Standard Library}}
{{cpp/standard library/navbar}}

The C++ standard library provides a wide range of facilities that are usable in standard C++.

===Category===
The [[cpp/utility#Language support|language support library]] provides components that are required by certain parts of the C++ language, such as memory allocation ([[cpp/language/new|new]]/[[cpp/language/delete|delete]]) and [[cpp/language/exceptions|exception processing]].

{{rrev|since=c++20|
The [[cpp/concepts|concepts library]] describes library components that C++ programs may use to perform compile-time validation of [[cpp/language/template parameters|template arguments]] and perform function dispatch based on properties of types.
}}

The [[cpp/error|diagnostics library]] provides a consistent framework for reporting errors in a C++ program, including [[cpp/error#Exception categories|predefined exception classes]].

The [[cpp/memory|memory management library]] provides components for memory management, including [[cpp/memory#Smart pointers|smart pointers]]{{rev inl|since=c++11| and [[cpp/memory/scoped_allocator_adaptor|scoped allocator]]}}.

{{rrev|since=c++11|
The [[cpp/meta|metaprogramming library]] describes facilities for use in [[cpp/language/templates|templates]] and during constant evaluation, including [[cpp/meta#Type traits|type traits]]{{rev inl|since=c++14|, [[cpp/utility/integer_sequence|integer sequence]],}} and [[cpp/numeric/ratio|rational arithmetic]].
}}

The [[cpp/utility#General-purpose utilities|general utilities library]] includes components used by other library elements, such as a [[cpp/memory#Allocators|predefined storage allocator]] for dynamic storage management, and components used as infrastructure in C++ programs, such as{{rev inl|since=c++11| [[cpp/utility/tuple|tuples]] and}} [[cpp/utility/functional|function wrappers]].

The [[cpp/string|strings library]] provides support for manipulating text represented as homogeneous sequences of following types: {{c/core|char}}{{rev inl|since=c++20|, {{c/core|char8_t}}}}{{rev inl|since=c++11|, {{c/core|char16_t}}, {{c/core|char32_t}}}}, {{c/core|wchar_t}}, and any other character-like types.

The [[cpp/container|containers]], [[cpp/iterator|iterators]]{{rev inl|since=c++20|, [[cpp/ranges|ranges]]}}, and [[cpp/algorithm|algorithms]] libraries provide a C++ program with access to a subset of the most widely used algorithms and data structures.

The [[cpp/numeric|numerics library]] provides [[cpp/numeric#Numeric algorithms|numeric algorithms]] and [[cpp/numeric/complex|complex number]] components that extend support for numeric processing. The [[cpp/numeric/valarray|valarray]] component provides support for n-at-a-time processing, potentially implemented as parallel operations on platforms that support such processing.{{rev inl|since=c++11| The [[cpp/numeric/random|random number component]] provides facilities for generating pseudo-random numbers.}}

The [[cpp/chrono|time library]] provides generally useful time utilities.

The [[cpp/locale|localization library]] provides extended internationalization support for text processing.

The [[cpp/io|input/output library]] provides the [[cpp/io#Stream-based I/O|iostream components]] that are the primary mechanism for C++ program input and output. They can be used with other elements of the library, particularly strings, locales, and iterators.

{{rrev|since=c++11|
The [[cpp/regex|regular expressions library]] provides regular expression matching and searching.

The [[cpp/thread|thread support library]] provides components to create and manage threads, including [[cpp/atomic/atomic|atomic operations]], [[cpp/thread/mutex|mutual exclusion]], and inter-thread communication.
}}

===Library contents===
The C++ standard library provides definitions for the [[cpp/language/basic concepts|entities]] and [[cpp/preprocessor/replace|macros]] described in the synopses of the [[cpp/headers|C++ standard library headers]], unless otherwise specified.

All library entities except {{lc|operator new}} and {{lc|operator delete}} are defined within the namespace {{c|std}} or [[cpp/language/namespace|namespaces]] nested within namespace {{c|std}} (except the entities for the C standard library facilities, see below).{{rev inl|since=c++11| It is unspecified whether names declared in a specific namespace are declared directly in that namespace or in an [[cpp/language/namespace#Inline namespaces|inline namespace]] inside that namespace.}}

====Headers====
Each element of the C++ standard library is declared or defined (as appropriate) in a ''header''. A header is not necessarily a source file, nor are the sequences delimited by < and > in header names necessarily valid source file names.

The C++ standard library provides the ''C++ library headers'' and ''additional C++ headers for C library facilities'' (see '[[cpp/headers|headers]]' page for descriptions):
{|class="wikitable"
|-style="text-align:center; font-size:16px; line-height:16px;"
!colspan="5"|C++ library headers
|-
|{{header|algorithm}}
|{{header|iomanip}}
|{{header|list}}
|{{header|ostream}}
|{{header|streambuf}}
|-
|{{header|bitset}}
|{{header|ios}}
|{{header|locale}}
|{{header|queue}}
|{{header|string}}
|-
|{{header|complex}}
|{{header|iosfwd}}
|{{header|map}}
|{{header|set}}
|{{header|typeinfo}}
|-
|{{header|deque}}
|{{header|iostream}}
|{{header|memory}}
|{{header|sstream}}
|{{header|utility}}
|-
|{{header|exception}}
|{{header|istream}}
|{{header|new}}
|{{header|stack}}
|{{header|valarray}}
|-
|{{header|fstream}}
|{{header|iterator}}
|{{header|numeric}}
|{{header|stdexcept}}
|{{header|vector}}
|-
|{{header|functional}}
|{{header|limits}}
|
|
|
|-style="text-align:center"
!colspan="5"|Headers added in C++11
|-
|{{header|array}}
|{{header|condition_variable}}
|{{header|mutex}}
|{{header|scoped_allocator}}
|{{header|type_traits}}
|-
|{{header|atomic}}
|{{header|forward_list}}
|{{header|random}}
|{{header|system_error}}
|{{header|typeindex}}
|-
|{{header|chrono}}
|{{header|future}}
|{{header|ratio}}
|{{header|thread}}
|{{header|unordered_map}}
|-
|{{header|codecvt}}
|{{header|initializer_list}}
|{{header|regex}}
|{{header|tuple}}
|{{header|unordered_set}}
|-style="text-align:center"
!colspan="5"|Headers added in C++14
|-
|{{header|shared_mutex}}
|
|
|
|
|-style="text-align:center"
!colspan="5"|Headers added in C++17
|-
|{{header|any}}
|{{header|execution}}
|{{header|memory_resource}}
|{{header|string_view}}
|{{header|variant}}
|-
|{{header|charconv}}
|{{header|filesystem}}
|{{header|optional}}
|
|
|-style="text-align:center"
!colspan="5"|Headers added in C++20
|-
|{{header|barrier}}
|{{header|concepts}}
|{{header|latch}}
|{{header|semaphore}}
|{{header|stop_token}}
|-
|{{header|bit}}
|{{header|coroutine}}
|{{header|numbers}}
|{{header|source_location}}
|{{header|syncstream}}
|-
|{{header|compare}}
|{{header|format}}
|{{header|ranges}}
|{{header|span}}
|{{header|version}}
|-style="text-align:center"
!colspan="5"|Headers added in C++23
|-
|{{header|expected}}
|{{header|flat_set}}
|{{header|mdspan}}
|{{header|spanstream}}
|{{header|stdfloat}}
|-
|{{header|flat_map}}
|{{header|generator}}
|{{header|print}}
|{{header|stacktrace}}
|
|-style="text-align:center"
!colspan="5"|Headers added in C++26
|-
|{{header|debugging}}
|{{header|inplace_vector}}
|{{header|linalg}}
|{{header|rcu}}
|{{header|text_encoding}}
|-
|{{header|hazard_pointer}}
|
|
|
|
|-style="text-align:center; font-size:16px; line-height:16px;"
!colspan="5"|Removed headers
|-
|{{header|codecvt}}
|colspan="4"|{{mark life|since=c++11|deprecated=c++17|removed=c++26}}
|-
|{{header|strstream}}
|colspan="4"|{{mark life|deprecated=c++98|removed=c++26}}
|}

{|class="wikitable"
|-style="text-align:center; font-size:16px; line-height:16px;"
!colspan="4"|C++ headers for C library facilities
|-
|{{header|cassert}}
|{{header|clocale}}
|{{header|cstdarg}}
|{{header|cstring}}
|-
|{{header|cctype}}
|{{header|cmath}}
|{{header|cstddef}}
|{{header|ctime}}
|-
|{{header|cerrno}}
|{{header|csetjmp}}
|{{header|cstdio}}
|{{header|cwchar}}
|-
|{{header|cfloat}}
|{{header|csignal}}
|{{header|cstdlib}}
|{{header|cwctype}}
|-
|{{header|climits}}
|
|
|
|-style="text-align:center"
!colspan="4"|Headers added in C++11
|-
|{{header|cfenv}}
|{{header|cinttypes}}
|{{header|cstdint}}
|{{header|cuchar}}
|-style="text-align:center; font-size:16px; line-height:16px;"
!colspan="5"|Removed headers
|-
|{{header|ccomplex}}
|colspan="4"|{{mark life|since=c++11|deprecated=c++17|removed=c++20}}
|-
|{{header|ciso646}}
|colspan="4"|{{mark until c++20|removed=yes}}
|-
|{{header|cstdalign}}
|colspan="4"|{{mark life|since=c++11|deprecated=c++17|removed=c++20}}
|-
|{{header|cstdbool}}
|colspan="4"|{{mark life|since=c++11|deprecated=c++17|removed=c++20}}
|-
|{{header|ctgmath}}
|colspan="4"|{{mark life|since=c++11|deprecated=c++17|removed=c++20}}
|}

A [[cpp/freestanding|freestanding implementation]] has an implementation-defined set of headers, see [[cpp/freestanding#header requirements|here]] for the minimal requirement on the set of headers.

===C standard library===
The C++ standard library also makes available the facilities of the C standard library, suitably adjusted to ensure static type safety. The descriptions of many library functions rely on the C standard library for the semantics of those functions.

In some cases, the signatures specified in standard C++ may be different from the signatures in the C standard library, and additional overloads may be declared, but the behavior and the preconditions {{rev inl|since=c++17|(including those implied by C's [[c/language/restrict|{{c/core|restrict}}]])}} are the same unless otherwise stated.

For compatibility with the C standard library, the C++ standard library provides the C headers listed below. The intended use of these headers is for interoperability only. It is possible that C++ source files need to include one of these headers in order to be valid ISO C. Source files that are not intended to also be valid ISO C should not use any of the C headers. See [[cpp/headers#C compatibility headers|here]] for descriptions.
{|class="wikitable"
|-style="text-align:center; font-size:16px; line-height:16px;"
!colspan="4"|C headers
|-
|{{ltt|cpp/header/cassert|<assert.h>}}
|{{ltt|cpp/header/climits|<limits.h>}}
|{{ltt|cpp/header/cstdarg|<stdarg.h>}}
|{{ltt|cpp/header/cstring|<string.h>}}
|-
|{{ltt|cpp/header/cctype|<ctype.h>}}
|{{ltt|cpp/header/clocale|<locale.h>}}
|{{ltt|cpp/header/cstddef|<stddef.h>}}
|{{ltt|cpp/header/ctime|&lt;time.h>}}
|-
|{{ltt|cpp/header/cerrno|<errno.h>}}
|{{ltt|cpp/header/cmath|<math.h>}}
|{{ltt|cpp/header/cstdio|<stdio.h>}}
|{{ltt|cpp/header/cwchar|<wchar.h>}}
|-
|{{ltt|cpp/header/cfloat|<float.h>}}
|{{ltt|cpp/header/csetjmp|<setjmp.h>}}
|{{ltt|cpp/header/cstdlib|<stdlib.h>}}
|{{ltt|cpp/header/cwctype|<wctype.h>}}
|-
|{{ltt|cpp/header/ciso646|<iso646.h>}}
|{{ltt|cpp/header/csignal|<signal.h>}}
|
|
|-style="text-align:center"
!colspan="4"|Headers added in C++11
|-
|{{ltt|cpp/header/ccomplex|<complex.h>}}
|{{ltt|cpp/header/cinttypes|<inttypes.h>}}
|{{ltt|cpp/header/cstdbool|<stdbool.h>}}
|{{ltt|cpp/header/ctgmath|<tgmath.h>}}
|-
|{{ltt|cpp/header/cfenv|<fenv.h>}}
|{{ltt|cpp/header/cstdalign|<stdalign.h>}}
|{{ltt|cpp/header/cstdint|<stdint.h>}}
|{{ltt|cpp/header/cuchar|<uchar.h>}}
|-style="text-align:center"
!colspan="4"|Headers added in C++23
|-
|{{ltt|cpp/header/stdatomic.h|<stdatomic.h>}}
|
|
|
|}

Except otherwise noted, the contents of each header {{tt|c''xxx''}} is the same as that of the corresponding header {{tt|''xxx''.h}} as specified in the [[c/header|C standard library]]. In the C++ standard library, however, the declarations (except for names which are defined as macros in C) are within namespace scope of the namespace {{c|std}}. It is unspecified whether these names (including any overloads added) are first declared within the global namespace scope and are then injected into namespace {{c|std}} by explicit [[cpp/language/namespace#Using-declarations|using-declarations]].

Names which are defined as macros in C ({{ltt|cpp/error/assert|assert}}, {{ltt|cpp/types/offsetof|offsetof}}, {{ltt|cpp/utility/program/setjmp|setjmp}}, {{ltt|cpp/utility/variadic/va_arg|va_arg}}, {{ltt|cpp/utility/variadic/va_end|va_end}} and {{ltt|cpp/utility/variadic/va_start|va_start}}) must be defined as macros in the C++ standard library, even if C grants license for implementation as functions.

Names that are defined as functions in C must be defined as functions in the C++ standard library. This disallows the practice, allowed in C, of providing a masking macro in addition to the function prototype. The only way to achieve equivalent inline behavior in C++ is to provide a definition as an extern [[cpp/language/inline|inline function]].

Identifiers that are keywords or operators in C++ cannot be defined as macros in C++ standard library headers. In particular, including the standard header {{ltt|cpp/header/ciso646|<iso646.h>}} has no effect.

====Names associated with safe functions in standard C {{mark since c++17}}====
If any C++ header is included, it is implementation-defined whether any of the following C standard Annex K names is declared in the global namespace (none of them is declared in namespace {{c|std}}):

{|class="wikitable"
|-style="text-align:center"
!colspan="4"|C standard Annex K names
|-
|{{ltt|c/error/abort_handler_s}}
|{{ltt|c/string/multibyte/mbstowcs|mbstowcs_s}}
|{{ltt|c/string/byte/strncat|strncat_s}}
|{{ltt|c/io/vfwscanf|vswscanf_s}}
|-
|{{ltt|c/chrono/asctime|asctime_s}}
|{{ltt|c/string/byte/memcpy|memcpy_s}}
|{{ltt|c/string/byte/strncpy|strncpy_s}}
|{{ltt|c/io/vfwprintf|vwprintf_s}}
|-
|{{ltt|c/algorithm/bsearch|bsearch_s}}
|{{ltt|c/string/byte/memmove|memmove_s}}
|{{ltt|c/string/byte/strtok|strtok_s}}
|{{ltt|c/io/vfwscanf|vwscanf_s}}
|-
|{{ltt|c/error/set_constraint_handler_s|constraint_handler_t}}
|{{ltt|c/string/byte/memset|memset_s}}
|{{ltt|c/io/fwprintf|swprintf_s}}
|{{ltt|c/string/multibyte/wcrtomb|wcrtomb_s}}
|-
|{{ltt|c/chrono/ctime|ctime_s}}
|{{ltt|c/io/fprintf|printf_s}}
|{{ltt|c/io/fwscanf|swscanf_s}}
|{{ltt|c/string/wide/wcscat|wcscat_s}}
|-
|{{ltt|c/error|errno_t}}
|{{ltt|c/algorithm/qsort|qsort_s}}
|{{ltt|c/io/tmpfile|tmpfile_s}}
|{{ltt|c/string/wide/wcscpy|wcscpy_s}}
|-
|{{ltt|c/io/fopen|fopen_s}}
|{{ltt|c/error|RSIZE_MAX}}
|{{ltt|c/io/tmpnam|TMP_MAX_S}}
|{{ltt|c/string/wide/wcsncat|wcsncat_s}}
|-
|{{ltt|c/io/fprintf|fprintf_s}}
|{{ltt|c/error|rsize_t}}
|{{ltt|c/io/tmpnam|tmpnam_s}}
|{{ltt|c/string/wide/wcsncpy|wcsncpy_s}}
|-
|{{ltt|c/io/freopen|freopen_s}}
|{{ltt|c/io/fscanf|scanf_s}}
|{{ltt|c/io/vfprintf|vfprintf_s}}
|{{ltt|c/string/wide/wcslen|wcsnlen_s}}
|-
|{{ltt|c/io/fscanf|fscanf_s}}
|{{ltt|c/error/set_constraint_handler_s}}
|{{ltt|c/io/vfscanf|vfscanf_s}}
|{{ltt|c/string/multibyte/wcsrtombs|wcsrtombs_s}}
|-
|{{ltt|c/io/fwprintf|fwprintf_s}}
|{{ltt|c/io/fprintf|snprintf_s}}
|{{ltt|c/io/vfwprintf|vfwprintf_s}}
|{{ltt|c/string/wide/wcstok|wcstok_s}}
|-
|{{ltt|c/io/fwscanf|fwscanf_s}}
|{{ltt|c/io/fwprintf|snwprintf_s}}
|{{ltt|c/io/vfwscanf|vfwscanf_s}}
|{{ltt|c/string/multibyte/wcstombs|wcstombs_s}}
|-
|{{ltt|c/io/gets|gets_s}}
|{{ltt|c/io/fscanf|sscanf_s}}
|{{ltt|c/io/vfprintf|vprintf_s}}
|{{ltt|c/string/wide/wmemcpy|wmemcpy_s}}
|-
|{{ltt|c/chrono/gmtime|gmtime_s}}
|{{ltt|c/string/multibyte/mbstowcs|mbstowcs_s}}
|{{ltt|c/io/vfscanf|vscanf_s}}
|{{ltt|c/io/vfwscanf|vswscanf_s}}
|-
|{{ltt|c/error/abort_handler_s}}
|{{ltt|c/string/byte/strcat|strcat_s}}
|{{ltt|c/io/vfprintf|vsnprintf_s}}
|{{ltt|c/string/wide|wmemmove|wmemmove_s}}
|-
|{{ltt|c/error/ignore_handler_s}}
|{{ltt|c/string/byte/strcpy|strcpy_s}}
|{{ltt|c/io/vfwprintf|vsnwprintf_s}}
|{{ltt|c/io/fwprintf|wprintf_s}}
|-
|{{ltt|c/chrono/localtime|localtime_s}}
|{{ltt|c/string/byte/strerror|strerrorlen_s}}
|{{ltt|c/io/vfprintf|vsprintf_s}}
|{{ltt|c/io/fwscanf|wscanf_s}}
|-
|{{ltt|c/io/tmpnam|L_tmpnam_s}}
|{{ltt|c/string/byte/strerror|strerror_s}}
|{{ltt|c/io/vfscanf|vsscanf_s}}
|
|-
|{{ltt|c/string/multibyte/mbsrtowcs|mbsrtowcs_s}}
|{{ltt|c/string/byte/strlen|strlen_s}}
|{{ltt|c/io/vfwprintf|vswprintf_s}}
|
|}

===Using the library===
====Including headers====
The entities in the C++ standard library are defined in headers, whose contents are made available to a translation unit when it contains the appropriate {{ltt|cpp/preprocessor/include|#include}} preprocessing directive.

A translation unit may include library headers in any order. Each may be included more than once, with no effect different from being included exactly once, except that the effect of including either {{header|cassert}} or {{ltt|cpp/header/cassert|<assert.h>}} depends each time on the lexically current definition of {{c|NDEBUG}}.

A translation unit can only include a header outside of any declaration or definition, and lexically before the first reference in that translation unit to any of the entities declared in that header. No diagnostic is required.

{{rrev|since=c++20|
In [[cpp/language/modules|module units]], headers can only be included in [[cpp/language/modules#Global module fragment|global module fragments]].
}}


{{rev begin}}
{{rev|since=c++20|
====Importing headers====
The [[#Headers|C++ library headers]], or, for a freestanding implementation, the subset of such headers that are provided by the implementation, are collectively known as the ''importable C++ library headers''.

The contents of importable C++ library headers are made available to a translation unit when it contains the appropriate [[cpp/language/modules#Importing modules and headers|import declaration]].
}}
{{rev|since=c++23|
====Importing modules====
The C++ standard library provides the following ''C++ library modules'':
* The [[cpp/language/modules#Module declarations|named module]] {{c|std}} exports declarations in namespace {{tt|std}} that are provided by the importable C++ library headers (e.g. {{lc|std::rotr}} from {{header|bit}}) and the [[#Headers|C++ headers for C library facilities]] (e.g. {{lc|std::puts}} from {{header|cstdio}}). It additionally exports declarations in the global namespace for the storage [[cpp/memory/new/operator new|allocation]] and [[cpp/memory/new/operator delete|deallocation]] functions that are provided by {{header|new}} (e.g. {{lc|operator new|::operator new}}).
* The named module {{c|std.compat}} exports the same declarations as the named module {{c|std}}, and additionally exports declarations in the global namespace corresponding to the declarations in namespace {{tt|std}} that are provided by the C++ headers for C library facilities (e.g. {{lc|std::fclose|::fclose}}).

For each declaration in the standard library,
* the module it [[cpp/language/modules#Module ownership|attaches to]] is unspecified, and
* it denotes the same [[cpp/language/basic concepts|entity]] regardless of whether it was made reachable through including a header, importing a header unit, or importing a C++ library module.

{{feature test macro|__cpp_lib_modules|Standard library modules {{c|std}} and {{c|std.compat}}|value=202207L|std=C++23}}
}}
{{rev end}}

====Linkage====
Entities in the C++ standard library have [[cpp/language/storage duration#external linkage|external linkage]]. Unless otherwise specified, objects and functions have the default {{c/core|extern "C++"}} [[cpp/language/language linkage|linkage]].

Whether a name from the C standard library declared with external linkage has {{c/core|extern "C"}} or {{c/core|extern "C++"}} linkage is implementation-defined. The C++ standard recommends using {{c/core|extern "C++"}} in this case.

Objects and functions defined in the library and required by a C++ program are included in the program prior to program startup.

===Requirements on standard library implementations===
====Guarantees====
A C++ header must provide [[cpp/language/declarations|declarations]] and [[cpp/language/definition|definitions]] that appear in
* the synopsis of that header, or
* the synopsis of another header which is appeared to be included in the synopsis of that header.

For types and macros defined in multiple headers (such as {{ltt|cpp/types/NULL}}), including any number of these headers in any order never violates the [[cpp/language/definition#One Definition Rule|one definition rule]].

Unless otherwise specified, all [[cpp/preprocessor/replace#Object-like macros|object-like macros]] defined by the C standard library that expand to integral [[cpp/language/constant expression|constant expressions]] can be used in [[cpp/preprocessor/conditional|{{tt|#if}}]] preprocessing directives.

Calling a standard library non-member function signature always results in actually calling that function. Therefore a conforming standard library implementation cannot define additional non-member functions that may be called by a valid C++ program.

Non-member function signatures are never declared with additional [[cpp/language/default arguments|default arguments]].

Unless otherwise specified, calls made by functions in the standard library to non-operator, non-member functions do not use functions from another [[cpp/language/namespace|namespace]] which are found through [[cpp/language/adl|argument-dependent name lookup]].

For each [[cpp/language/friend|friend declaration]] of a function (template) within a class (template) definition, no other declaration is provided for that function (template).

{{rrev|since=c++11|1=
Standard library function signatures can only be declared as {{c/core|constexpr}} if they are required to be [[cpp/language/constexpr|constexpr]] (libstdc++ cmath [https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102916 is notably non-conforming] here). If a header provides any non-defining declarations of constexpr functions or constructors, the corresponding definitions should also be provided within that header.

Unless otherwise specified, each standard library function should meet each of the following requirements to prevent [[cpp/language/memory model#Threads and data races|data races]]:
* A C++ standard library function cannot (directly or indirectly) access objects accessible by threads other than the current thread unless the objects are accessed (directly or indirectly) via the function’s arguments, including {{c|this}}.
* A C++ standard library function cannot (directly or indirectly) modify objects accessible by threads other than the current thread unless the objects are accessed (directly or indirectly) via the function’s non-const arguments, including {{c|this}}.
** For example, an object with static storage duration cannot be used for internal purposes without synchronization because doing so can cause a data race even in programs that do not explicitly share objects between threads.
* A C++ standard library function cannot access objects indirectly accessible via its arguments or via elements of its [[cpp/container|container]] arguments except by invoking functions required by its specification on those container elements.
* An operation on [[cpp/iterator|iterators]] obtained by calling a standard library container or string member function can access, but not modify, the underlying container.
** In particular, container operations that invalidate iterators conflict with operations on iterators associated with that container.
* A C++ standard library function can only perform all operations solely within the current thread if those operations have effects that are [[cpp/language/memory model#Memory order|visible]] to users.
** Operations without visible side effects can be parallelized.
}}

For each class defined in the C++ standard library required to be [[cpp/language/derived class|derived]] from another class defined in the C++ standard library,
* the base class must be [[cpp/language/derived class#Virtual base classes|virtual]] if it is specified as {{c/core|virtual}},
* the base class cannot be virtual if it is not specified as {{c/core|virtual}}, and
* unless otherwise specified, types with distinct names shall be distinct types.

{{rrev|since=c++11|
Unless otherwise specified, all types specified in the C++ standard library are non-[[cpp/language/final|final]] types.
}}

If a function defined in the C++ standard library is specified to throw an [[cpp/language/exceptions|exception]] (in a particular situation) of a given type, the exception thrown can only have that type or a type derived from that type so that an exception handler for the base type can catch it.

Functions from the C standard library can only throw exceptions when such a function calls a program-supplied function that throws an exception ({{ltt|cpp/algorithm/qsort|qsort()}} and {{ltt|cpp/algorithm/bsearch|bsearch()}} meet this condition).

Destructor operations defined in the C++ standard library never throw exceptions. Every destructor in the C++ standard library behaves as if it had a [[cpp/language/noexcept spec|non-throwing exception specification]].

{{rrev|since=c++11|
If a function in the C++ standard library report errors via a {{lc|std::error_code}} object, that object's {{ltt|cpp/error/error_code/category|category()}} member must return {{lc|std::system_category()}} for errors originating from the operating system, or a reference to an implementation-defined {{lc|std::error_category}} object for errors originating elsewhere. The possible values of {{ltt|cpp/error/error_code/value|value()}} for each of these error categories should be defined.

Objects of types defined in the C++ standard library may be [[cpp/language/move constructor|moved from]]. Move operations can either be explicitly specified or implicitly generated. Unless otherwise specified, such moved-from objects will be placed in a valid but unspecified state.

An object of a type defined in the C++ standard library may be [[cpp/language/move assignment|move-assigned]] to itself. Unless otherwise specified, such an assignment places the object in a valid but unspecified state.
}}

====Implementation freedom====
It is unspecified whether any member or non-member functions in the C++ standard library are defined as [[cpp/language/inline|inline]].

For a non-[[cpp/language/virtual|virtual]] C++ standard library member function, a different set of member function signatures can be declared, provided that any call to that member function that would select an overload from the given set of declarations behaves as if that overload was selected. This allows, for instance:
* adding parameters with default arguments,
* replacing a member function with default arguments with two or more member functions with equivalent behavior, or
* adding additional signatures for a member function name.

Unless otherwise specified, it is implementation-defined which functions in the C++ standard library may be recursively reentered.

{{rrev|since=c++11|
C++ standard library implementations can share their own internal objects between threads if the objects are not visible to users and are protected against data races.
}}

It is unspecified whether any function signature or class in the C++ standard library is a friend of another class in the C++ standard library.

The names and global function signatures described [[#Library contents|here]] are reserved to the implementation.

Any class in the C++ standard library can be derived from a class with a name reserved to the implementation. If a class defined in the C++ standard library is required to be derived from other classes in the C++ standard library, that class can be derived directly from the required base or indirectly through a hierarchy of base classes with names reserved to the implementation.

If a function defined in the C++ standard library is not specified to throw an exception but does not have a non-throwing exception specification, the exception thrown is implementation-defined, but its type should be {{lc|std::exception}} or any type derived from {{lc|std::exception}}.

The exception specification for a non-virtual function can be strengthened by adding a non-throwing exception specification.

===Defect reports===
{{dr list begin}}
{{dr list item|wg=lwg|dr=1|std=C++98|before=the language linkages of the names from<br>the C standard library were unspecified|after=they are<br>implementation-defined}}
{{dr list item|wg=lwg|dr=119|std=C++98|before=the exception specifications of virtual<br>functions could be strengthened|after=only allowed for<br>non-virtual functions}}
{{dr list item|wg=lwg|dr=147|std=C++98|before=the specification on non-member<br>functions only considered global functions|after=also considers<br>non-global functions}}
{{dr list item|wg=lwg|dr=225|std=C++98|before=standard library functions might call non-member functions<br>from other namespaces due to argument-dependent lookup|after=prohibited unless<br>otherwise specified}}
{{dr list item|wg=lwg|dr=336|std=C++98|before={{header|strstream}} was not a C++ library header|after=it is a C++ library header}}
{{dr list item|wg=lwg|dr=343|std=C++98|before=library header dependencies were not specified|after=specified (listed in synopses)}}
{{dr list item|wg=lwg|dr=456|std=C++98|before=C++ headers for C library facilities could<br>only provide definitions in namespace {{c|std}}|after=allowed to define in global namespace<br>and then inject into namespace {{c|std}}}}
{{dr list item|wg=lwg|dr=465|std=C++98|before=identifiers that are keywords or operators in C++ could<br>be defined as macros in C++ standard library headers<br>(only {{header|ciso646}} is required not to define them as macros)|after=all C++ standard<br>library headers cannot<br>define them as macros}}
{{dr list item|wg=lwg|dr=1178|std=C++98|before=C++ headers must include a C++ header<br>that contains any needed definition|after=C++ headers must provide declarations<br>and definitions that are directly or<br>indirectly included in its synopsis}}
{{dr list item|wg=lwg|dr=2013|std=C++11|before=it was unspecified whether the functions not<br>required by the standard to be constexpr can<br>be declared {{c/core|constexpr}} by the standard library|after=prohibited}}
{{dr list item|wg=lwg|dr=2225|std=C++98|before=a diagnostic was required if a header<br>is included at an incorrect position|after=no diagnostic is<br>required in this case}}
{{dr list end}}

{{langlinks|ar|de|es|fr|it|ja|pt|ru|zh}}
Templates used on this page:
Template:!! (view source)
Template:c (view source) (protected)
Template:c/core (view source) (protected)
Template:cpp/navbar content (view source)
Template:cpp/navbar heading (view source)
Template:cpp/standard library/hardened functions (view source)
Template:cpp/standard library/navbar (view source)
Template:cpp/standard library/navbar content (view source)
Template:cpp/standard library/navbar heading (view source)
Template:dr list begin (view source)
Template:dr list end (view source)
Template:dr list item (view source)
Template:ftm (view source)
Template:ftm begin (view source)
Template:ftm end (view source)
Template:ftm link (view source)
Template:get lang (view source) (protected)
Template:get lang formal (view source)
Template:header (view source)
Template:i (view source)
Template:langlinks (view source) (protected)
Template:langlinks/one (view source) (protected)
Template:lc (view source) (protected)
Template:lines (view source) (protected)
Template:lsd (view source)
Template:lt (view source)
Template:ltf (view source) (protected)
Template:ltt (view source) (protected)
Template:ltt/core (view source) (protected)
Template:ltt std (view source)
Template:mark (view source) (protected)
Template:mark c++11 (view source) (protected)
Template:mark c++17 (view source) (protected)
Template:mark c++20 (view source)
Template:mark c++26 (view source)
Template:mark deprecated c++17 (view source)
Template:mark deprecated c++98 (view source)
Template:mark life (view source)
Template:mark rev (view source) (protected)
Template:mark since c++11 (view source) (protected)
Template:mark since c++14 (view source) (protected)
Template:mark since c++17 (view source)
Template:mark since c++20 (view source)
Template:mark since c++23 (view source)
Template:mark since c++26 (view source)
Template:mark until c++20 (view source)
Template:mark until c++26 (view source)
Template:maybe (view source)
Template:n/a (view source) (protected)
Template:navbar (view source)
Template:navbar editlink (view source) (protected)
Template:nbsp (view source) (protected)
Template:nv (view source) (protected)
Template:nv begin (view source) (protected)
Template:nv end (view source) (protected)
Template:nv h2 (view source) (protected)
Template:nv ln (view source) (protected)
Template:rev (view source) (protected)
Template:rev begin (view source)
Template:rev end (view source)
Template:rev inl (view source)
Template:rrev (view source)
Template:sep (view source)
Template:title (view source) (protected)
Template:trim (view source) (protected)
Template:tt (view source) (protected)
Template:ttb (view source) (protected)
Template:yes (view source) (protected)
Return to cpp/standard library.
cppreference.com

Search

Namespaces

Variants

Views

Actions

View source for cpp/standard library

Navigation

Tools
