| Trigraph | Replacement | Trigraph | Replacement | Trigraph | Replacement |
| ??= | # | ??( | [ | ??< | { |
| ??/ | \ | ??) | ] | ??> | } |
| ??' | ^ | ??! | | | ??- | ~ |
| Alternative | Primary | Alternative | Primary | Alternative | Primary |
| <% | { | and | && | and_eq | &= |
| %> | } | bitor | | | or_eq | |= |
| <: | [ | or | || | xor_eq | ^= |
| :> | ] | xor | ^ | not | ! |
| %: | # | compl | ~ | not_eq | != |
| %:%: | ## | bitand | & |
| alignas | continue | friend | register | true |
| alignof | decltype | goto | reinterpret_cast | try |
| asm | default | if | return | typedef |
| auto | delete | inline | short | typeid |
| bool | do | int | signed | typename |
| break | double | long | sizeof | union |
| case | dynamic_cast | mutable | static | unsigned |
| catch | else | namespace | static_assert | using |
| char | enum | new | static_cast | virtual |
| char16_t | explicit | noexcept | struct | void |
| char32_t | export | nullptr | switch | volatile |
| class | extern | operator | template | wchar_t |
| const | false | private | this | while |
| constexpr | float | protected | thread_local | |
| const_cast | for | public | throw |
| Suffix | Decimal literal | Binary, octal, or hexadecimal literal |
| none | int | int |
| long int | unsigned int | |
| long long int | long int | |
| unsigned long int | ||
| long long int | ||
| unsigned long long int | ||
| u or U | unsigned int | unsigned int |
| unsigned long int | unsigned long int | |
| unsigned long long int | unsigned long long int | |
| l or L | long int | long int |
| long long int | unsigned long int | |
| long long int | ||
| unsigned long long int | ||
| Both u or U | unsigned long int | unsigned long int |
| and l or L | unsigned long long int | unsigned long long int |
| ll or LL | long long int | long long int |
| unsigned long long int | ||
| Both u or U | unsigned long long int | unsigned long long int |
| and ll or LL |
| new-line | NL(LF) | \n |
| horizontal tab | HT | \t |
| vertical tab | VT | \v |
| backspace | BS | \b |
| carriage return | CR | \r |
| form feed | FF | \f |
| alert | BEL | \a |
| backslash | \ | \\ |
| question mark | ? | \? |
| single quote | ' | \' |
| double quote | " | \" |
| octal number | ooo | \ooo |
| hex number | hhh | \xhhh |
| Source | Means | Source | Means | Source | Means | |||
| u"a" | u"b" | u"ab" | U"a" | U"b" | U"ab" | L"a" | L"b" | L"ab" |
| u"a" | "b" | u"ab" | U"a" | "b" | U"ab" | L"a" | "b" | L"ab" |
| "a" | u"b" | u"ab" | "a" | U"b" | U"ab" | "a" | L"b" | L"ab" |
| no cv-qualifier | < | const |
| no cv-qualifier | < | volatile |
| no cv-qualifier | < | const volatile |
| const | < | const volatile |
| volatile | < | const volatile |
| Specifier(s) | Type |
| type-name | the type named |
| simple-template-id | the type as defined in [temp.names] |
| char | “char” |
| unsigned char | “unsigned char” |
| signed char | “signed char” |
| char16_t | “char16_t” |
| char32_t | “char32_t” |
| bool | “bool” |
| unsigned | “unsigned int” |
| unsigned int | “unsigned int” |
| signed | “int” |
| signed int | “int” |
| int | “int” |
| unsigned short int | “unsigned short int” |
| unsigned short | “unsigned short int” |
| unsigned long int | “unsigned long int” |
| unsigned long | “unsigned long int” |
| unsigned long long int | “unsigned long long int” |
| unsigned long long | “unsigned long long int” |
| signed long int | “long int” |
| signed long | “long int” |
| signed long long int | “long long int” |
| signed long long | “long long int” |
| long long int | “long long int” |
| long long | “long long int” |
| long int | “long int” |
| long | “long int” |
| signed short int | “short int” |
| signed short | “short int” |
| short int | “short int” |
| short | “short int” |
| wchar_t | “wchar_t” |
| float | “float” |
| double | “double” |
| long double | “long double” |
| void | “void” |
| auto | placeholder for a type to be deduced |
| decltype(expression) | the type as defined below |
| Subclause | Expression | As member function | As non-member function |
| [over.unary] | @a | (a).operator@ ( ) | operator@ (a) |
| [over.binary] | a@b | (a).operator@ (b) | operator@ (a, b) |
| [over.ass] | a=b | (a).operator= (b) | |
| [over.sub] | a[b] | (a).operator[](b) | |
| [over.ref] | a-> | (a).operator-> ( ) | |
| [over.inc] | a@ | (a).operator@ (0) | operator@ (a, 0) |
| Conversion | Category | Rank | Subclause |
| No conversions required | Identity | ||
| Lvalue-to-rvalue conversion | [conv.lval] | ||
| Array-to-pointer conversion | Lvalue Transformation | Exact Match | [conv.array] |
| Function-to-pointer conversion | [conv.func] | ||
| Qualification conversions | Qualification Adjustment | [conv.qual] | |
| Integral promotions | [conv.prom] | ||
| Floating point promotion | Promotion | Promotion | [conv.fpprom] |
| Integral conversions | [conv.integral] | ||
| Floating point conversions | [conv.double] | ||
| Floating-integral conversions | [conv.fpint] | ||
| Pointer conversions | Conversion | Conversion | [conv.ptr] |
| Pointer to member conversions | [conv.mem] | ||
| Boolean conversions | [conv.bool] |
| Clause | Category | |
| [language.support] | Language support library | |
| [diagnostics] | Diagnostics library | |
| [utilities] | General utilities library | |
| [strings] | Strings library | |
| [localization] | Localization library | |
| [containers] | Containers library | |
| [iterators] | Iterators library | |
| [algorithms] | Algorithms library | |
| [numerics] | Numerics library | |
| [input.output] | Input/output library | |
| [re] | Regular expressions library | |
| [atomics] | Atomic operations library | |
| [thread] | Thread support library | |
| <algorithm> | <fstream> | <list> | <regex> | <tuple> |
| <array> | <functional> | <locale> | <scoped_allocator> | <type_traits> |
| <atomic> | <future> | <map> | <set> | <typeindex> |
| <bitset> | <initializer_list> | <memory> | <sstream> | <typeinfo> |
| <chrono> | <iomanip> | <mutex> | <stack> | <unordered_map> |
| <codecvt> | <ios> | <new> | <stdexcept> | <unordered_set> |
| <complex> | <iosfwd> | <numeric> | <streambuf> | <utility> |
| <condition_variable> | <iostream> | <ostream> | <string> | <valarray> |
| <deque> | <istream> | <queue> | <strstream> | <vector> |
| <exception> | <iterator> | <random> | <system_error> | |
| <forward_list> | <limits> | <ratio> | <thread> |
| <cassert> | <cinttypes> | <csignal> | <cstdio> | <cwchar> |
| <ccomplex> | <ciso646> | <cstdalign> | <cstdlib> | <cwctype> |
| <cctype> | <climits> | <cstdarg> | <cstring> | |
| <cerrno> | <clocale> | <cstdbool> | <ctgmath> | |
| <cfenv> | <cmath> | <cstddef> | <ctime> | |
| <cfloat> | <csetjmp> | <cstdint> | <cuchar> |
| Subclause | Header(s) | |
| <ciso646> | ||
| [support.types] | Types | <cstddef> |
| [support.limits] | Implementation properties | <cfloat> <limits> <climits> |
| [cstdint] | Integer types | <cstdint> |
| [support.start.term] | Start and termination | <cstdlib> |
| [support.dynamic] | Dynamic memory management | <new> |
| [support.rtti] | Type identification | <typeinfo> |
| [support.exception] | Exception handling | <exception> |
| [support.initlist] | Initializer lists | <initializer_list> |
| [support.runtime] | Other runtime support | <cstdalign> <cstdarg> <cstdbool> |
| [meta] | Type traits | <type_traits> |
| [atomics] | Atomics | <atomic> |
| Expression | Return type | Requirement |
| a == b | convertible to bool |
== is an equivalence relation,
that is, it has the following properties:
|
| Expression | Return type | Requirement |
| a < b | convertible to bool | < is a strict weak ordering relation ([alg.sorting]) |
| Expression | Post-condition |
| T t; | object t is default-initialized |
| T u{}; | object u is value-initialized |
| T() | a temporary object of type T is value-initialized |
| T{} |
| Expression | Post-condition |
| T u = rv; | u is equivalent to the value of rv before the construction |
| T(rv) | T(rv) is equivalent to the value of rv before the construction |
| rv's state is unspecified [ Note: rv must still meet the requirements of the library component that is using it. The operations listed in those requirements must work as specified whether rv has been moved from or not. — end note ] | |
| Expression | Post-condition |
| T u = v; | the value of v is unchanged and is equivalent to u |
| T(v) | the value of v is unchanged and is equivalent to T(v) |
| Expression | Return type | Return value | Post-condition |
| t = rv | T& | t | t is equivalent to the value of rv before the assignment |
| rv's state is unspecified. [ Note: rv must still meet the requirements of the library component that is using it. The operations listed in those requirements must work as specified whether rv has been moved from or not. — end note ] | |||
| Expression | Return type | Return value | Post-condition |
| t = v | T& | t | t is equivalent to v, the value of v is unchanged |
| Expression | Post-condition |
| u.~T() | All resources owned by u are reclaimed, no exception is propagated. |
| Expression | Return type | Operational semantics |
|
P u(np); | post: u == nullptr | |
| P u = np; | ||
| P(np) | post: P(np) == nullptr | |
| t = np | P& | post: t == nullptr |
| a != b | contextually convertible to bool | !(a == b) |
| a == np | contextually convertible to bool | a == P() |
| np == a | ||
| a != np | contextually convertible to bool | !(a == np) |
| np != a |
| Expression | Return type | Requirement |
| h(k) | size_t | The value returned shall depend only on the argument k for the duration of the program. [ Note: Thus all evaluations of the expression h(k) with the same value for k yield the same result for a given execution of the program. — end note ] [ Note: For two different values t1 and t2, the probability that h(t1) and h(t2) compare equal should be very small, approaching 1.0 / numeric_limits<size_t>::max(). — end note ] |
| h(u) | size_t | Shall not modify u. |
| Variable | Definition |
| T, U, C | any non-const object type ([basic.types]) |
| V | a type convertible to T |
| X | an Allocator class for type T |
| Y | the corresponding Allocator class for type U |
| XX | the type allocator_traits<X> |
| YY | the type allocator_traits<Y> |
| t | a value of type const T& |
| a, a1, a2 | values of type X& |
| a3 | an rvalue of type X |
| b | a value of type Y |
| c | a pointer of type C* through which indirection is valid |
| p | a value of type XX::pointer, obtained by calling a1.allocate, where a1 == a |
| q | a value of type XX::const_pointer obtained by conversion from a value p. |
| w | a value of type XX::void_pointer obtained by conversion from a value p |
| z | a value of type XX::const_void_pointer obtained by conversion from a value q or a value w |
| r | a value of type T& obtained by the expression *p. |
| s | a value of type const T& obtained by the expression *q or by conversion from a value r. |
| u | a value of type XX:const_void_pointer obtained by conversion from a result value of YY::allocate, or else a value of type (possibly const) std::nullptr_t. |
| v | a value of type V |
| n | a value of type XX::size_type. |
| Args | a template parameter pack |
| args | a function parameter pack with the pattern Args&& |
| Expression | Return type | Assertion/note | Default |
| pre-/post-condition | |||
| X::pointer | T* | ||
| X::const_pointer | X::pointer is convertible to X::const_pointer | pointer_traits<X::pointer>::rebind<const T> | |
| X::void_pointer Y::void_pointer | X::pointer is convertible to X::void_pointer. X::void_pointer and Y::void_pointer are the same type. | pointer_traits<X::pointer>::rebind<void> | |
| X::const_void_pointer Y::const_void_pointer | X::pointer, X::const_pointer, and X::void_pointer are convertible to X::const_void_pointer. X::const_void_pointer and Y::const_void_pointer are the same type. | pointer_traits<X::pointer>::rebind<const void> | |
| X::value_type | Identical to T | ||
| X::size_type | unsigned integer type | a type that can represent the size of the largest object in the allocation model. | make_unsigned_t<X::difference_type> |
| X::difference_type | signed integer type | a type that can represent the difference between any two pointers in the allocation model. | pointer_traits<X::pointer>::difference_type |
| typename X::template rebind<U>::other | Y | For all U (including T), Y::template rebind<T>::other is X. | See Note A, below. |
| *p | T& | ||
| *q | const T& | *q refers to the same object as *p | |
| p->m | type of T::m | pre: (*p).m is well-defined. equivalent to (*p).m | |
| q->m | type of T::m | pre: (*q).m is well-defined. equivalent to (*q).m | |
| static_- cast<X::pointer>(w) | X::pointer | static_cast<X::pointer>(w) == p | |
| static_cast<X ::const_pointer>(z) | X::const_pointer | static_cast<X ::const_pointer>(z) == q | |
| a.allocate(n) | X::pointer | Memory is allocated for n objects of type T but objects are not constructed. allocate may raise an appropriate exception.181 [ Note: If n == 0, the return value is unspecified. — end note ] | |
| a.allocate(n, u) | X::pointer | Same as a.allocate(n). The use of u is unspecified, but it is intended as an aid to locality. | a.allocate(n) |
| a.deallocate(p,n) | (not used) | All n T objects in the area pointed to by p shall be destroyed prior to this call. n shall match the value passed to allocate to obtain this memory. Does not throw exceptions. [ Note: p shall not be singular. — end note ] | |
| a.max_size() | X::size_type | the largest value that can meaningfully be passed to X::allocate() | numeric_limits<size_type>::max() |
| a1 == a2 | bool | returns true only if storage allocated from each can be deallocated via the other. operator== shall be reflexive, symmetric, and transitive, and shall not exit via an exception. | |
| a1 != a2 | bool | same as !(a1 == a2) | |
| a == b | bool | same as a == Y::rebind<T>::other(b) | |
| a != b | bool | same as !(a == b) | |
| X a1(a); X a1 = a; |
Shall not exit via an exception. post: a1 == a | ||
| X a(b); |
Shall not exit via an exception. post: Y(a) == b, a == X(b) | ||
| X a1(move(a)); X a1 = move(a); |
Shall not exit via an exception. post: a1 equals the prior value of a. | ||
| X a(move(b)); |
Shall not exit via an exception. post: a equals the prior value of X(b). | ||
| a.construct(c, args) | (not used) | Effect: Constructs an object of type C at c | ::new ((void*)c) C(forward<Args>(args)...) |
| a.destroy(c) | (not used) | Effect: Destroys the object at c | c->~C() |
| a.select_on_container_copy_construction() | X | Typically returns either a or X() | return a; |
| X::propagate_on_container_copy_assignment | Identical to or derived from true_type or false_type | true_type only if an allocator of type X should be copied when the client container is copy-assigned. | false_type |
| X::propagate_on_container_move_assignment | Identical to or derived from true_type or false_type | true_type only if an allocator of type X should be moved when the client container is move-assigned. | false_type |
| X::propagate_on_- container_swap | Identical to or derived from true_type or false_type | true_type only if an allocator of type X should be swapped when the client container is swapped. | false_type |
| Subclause | Header(s) | |
| [support.types] | Types | <cstddef> |
| <limits> | ||
| [support.limits] | Implementation properties | <climits> |
| <cfloat> | ||
| [cstdint] | Integer types | <cstdint> |
| [support.start.term] | Start and termination | <cstdlib> |
| [support.dynamic] | Dynamic memory management | <new> |
| [support.rtti] | Type identification | <typeinfo> |
| [support.exception] | Exception handling | <exception> |
| [support.initlist] | Initializer lists | <initializer_list> |
| <csignal> | ||
| <csetjmp> | ||
| <cstdalign> | ||
| [support.runtime] | Other runtime support | <cstdarg> |
| <cstdbool> | ||
| <cstdlib> | ||
| <ctime> | ||
| Type | Name(s) | |
| Macros: | NULL | offsetof |
| Types: | ptrdiff_t | size_t |
| max_align_t | nullptr_t | |
| Type | Name(s) | ||||
| Values: | |||||
| CHAR_BIT | INT_MAX | LONG_MAX | SCHAR_MIN | SHRT_MIN | ULLONG_MAX |
| CHAR_MAX | LLONG_MAX | LONG_MIN | SCHAR_MAX | UCHAR_MAX | ULONG_MAX |
| CHAR_MIN | LLONG_MIN | MB_LEN_MAX | SHRT_MAX | UINT_MAX | USHRT_MAX |
| INT_MIN | |||||
| Type | Name(s) | ||
| Values: | |||
| DBL_DIG | DBL_MIN_EXP | FLT_MAX_EXP | LDBL_MANT_DIG |
| DBL_EPSILON | DECIMAL_DIG | FLT_MIN | LDBL_MAX_10_EXP |
| DBL_MANT_DIG | FLT_DIG | FLT_MIN_10_EXP | LDBL_MAX_EXP |
| DBL_MAX | FLT_EPSILON | FLT_MIN_EXP | LDBL_MAX |
| DBL_MAX_10_EXP | FLT_EVAL_METHOD | FLT_RADIX | LDBL_MIN |
| DBL_MAX_EXP | FLT_MANT_DIG | FLT_ROUNDS | LDBL_MIN_10_EXP |
| DBL_MIN | FLT_MAX | LDBL_DIG | LDBL_MIN_EXP |
| DBL_MIN_10_EXP | FLT_MAX_10_EXP | LDBL_EPSILON | |
| Type | Name(s) | ||
| Macros: | EXIT_FAILURE | EXIT_SUCCESS | |
| Functions: | _Exit | abort | atexit |
| at_quick_exit | exit | quick_exit | |
| Type | Name(s) | |||
| Macros: | SIGABRT | SIGILL | SIGSEGV | SIG_DFL |
| SIG_IGN | SIGFPE | SIGINT | SIGTERM | SIG_ERR |
| Type: | sig_atomic_t | |||
| Functions: | raise | signal | ||
| Type | Name(s) | ||
| Macros: | va_arg | va_end | va_start |
| va_copy | |||
| Type: | va_list | ||
| Subclause | Header(s) | |
| [std.exceptions] | Exception classes | <stdexcept> |
| [assertions] | Assertions | <cassert> |
| [errno] | Error numbers | <cerrno> |
| [syserr] | System error support | <system_error> |
| Type | Name(s) | ||||
| Macros: | ECONNREFUSED | EIO | ENODEV | ENOTEMPTY | ERANGE |
| E2BIG | ECONNRESET | EISCONN | ENOENT | ENOTRECOVERABLE | EROFS |
| EACCES | EDEADLK | EISDIR | ENOEXEC | ENOTSOCK | ESPIPE |
| EADDRINUSE | EDESTADDRREQ | ELOOP | ENOLCK | ENOTSUP | ESRCH |
| EADDRNOTAVAIL | EDOM | EMFILE | ENOLINK | ENOTTY | ETIME |
| EAFNOSUPPORT | EEXIST | EMLINK | ENOMEM | ENXIO | ETIMEDOUT |
| EAGAIN | EFAULT | EMSGSIZE | ENOMSG | EOPNOTSUPP | ETXTBSY |
| EALREADY | EFBIG | ENAMETOOLONG | ENOPROTOOPT | EOVERFLOW | EWOULDBLOCK |
| EBADF | EHOSTUNREACH | ENETDOWN | ENOSPC | EOWNERDEAD | EXDEV |
| EBADMSG | EIDRM | ENETRESET | ENOSR | EPERM | errno |
| EBUSY | EILSEQ | ENETUNREACH | ENOSTR | EPIPE | |
| ECANCELED | EINPROGRESS | ENFILE | ENOSYS | EPROTO | |
| ECHILD | EINTR | ENOBUFS | ENOTCONN | EPROTONOSUPPORT | |
| ECONNABORTED | EINVAL | ENODATA | ENOTDIR | EPROTOTYPE | |
| Subclause | Header(s) | |
| [utility] | Utility components | <utility> |
| [pairs] | Pairs | <utility> |
| [tuple] | Tuples | <tuple> |
| [intseq] | Compile-time integer sequences | <utility> |
| [template.bitset] | Fixed-size sequences of bits | <bitset> |
| <memory> | ||
| [memory] | Memory | <cstdlib> |
| <cstring> | ||
| [smartptr] | Smart pointers | <memory> |
| [function.objects] | Function objects | <functional> |
| [meta] | Type traits | <type_traits> |
| [ratio] | Compile-time rational arithmetic | <ratio> |
| [time] | Time utilities | <chrono> |
| <ctime> | ||
| [allocator.adaptor] | Scoped allocators | <scoped_allocator> |
| [type.index] | Type indexes | <typeindex> |
| Type | Name(s) | |
| Macro: | NULL | |
| Type: | size_t | |
| Functions: | memchr | memcmp |
| memcpy | memmove | memset |
| Template | Condition | Comments |
|
template <class T> struct is_void; | T is void | |
|
template <class T> struct is_null_pointer; | T is std::nullptr_t ([basic.fundamental]) | |
|
template <class T> struct is_integral; | T is an integral type ([basic.fundamental]) | |
|
template <class T> struct is_floating_point; | T is a floating point type ([basic.fundamental]) | |
|
template <class T> struct is_array; | T is an array type ([basic.compound]) of known or unknown extent | Class template array ([array]) is not an array type. |
|
template <class T> struct is_pointer; | T is a pointer type ([basic.compound]) | Includes pointers to functions but not pointers to non-static members. |
|
template <class T> struct is_lvalue_reference; | T is an lvalue reference type ([dcl.ref]) | |
|
template <class T> struct is_rvalue_reference; | T is an rvalue reference type ([dcl.ref]) | |
|
template <class T> struct is_member_object_pointer; | T is a pointer to non-static data member | |
|
template <class T> struct is_member_function_pointer; | T is a pointer to non-static member function | |
|
template <class T> struct is_enum; | T is an enumeration type ([basic.compound]) | |
|
template <class T> struct is_union; | T is a union type ([basic.compound]) | |
|
template <class T> struct is_class; | T is a class type but not a union type ([basic.compound]) | |
|
template <class T> struct is_function; | T is a function type ([basic.compound]) |
| Template | Condition | Comments |
|
template <class T> struct is_reference; | T is an lvalue reference or an rvalue reference | |
|
template <class T> struct is_arithmetic; | T is an arithmetic type ([basic.fundamental]) | |
|
template <class T> struct is_fundamental; | T is a fundamental type ([basic.fundamental]) | |
|
template <class T> struct is_object; | T is an object type ([basic.types]) | |
|
template <class T> struct is_scalar; | T is a scalar type ([basic.types]) | |
|
template <class T> struct is_compound; | T is a compound type ([basic.compound]) | |
|
template <class T> struct is_member_pointer; | T is a pointer to non-static data member or non-static member function |
| Template | Condition | Preconditions |
|
template <class T> struct is_const; | T is const-qualified ([basic.type.qualifier]) | |
| template <class T> struct is_volatile; | T is volatile-qualified ([basic.type.qualifier]) | |
|
template <class T> struct is_trivial; | T is a trivial type ([basic.types]) | remove_all_extents_t<T> shall be a complete type or (possibly cv-qualified) void. |
| template <class T> struct is_trivially_copyable; | T is a trivially copyable type ([basic.types]) | remove_all_extents_t<T> shall be a complete type or (possibly cv-qualified) void. |
| template <class T> struct is_standard_layout; | T is a standard-layout type ([basic.types]) | remove_all_extents_t<T> shall be a complete type or (possibly cv-qualified) void. |
| template <class T> struct is_pod; | T is a POD type ([basic.types]) | remove_all_extents_t<T> shall be a complete type or (possibly cv-qualified) void. |
| template <class T> struct is_literal_type; | T is a literal type ([basic.types]) | remove_all_extents_t<T> shall be a complete type or (possibly cv-qualified) void. |
| template <class T> struct is_empty; | T is a class type, but not a union type, with no non-static data members other than bit-fields of length 0, no virtual member functions, no virtual base classes, and no base class B for which is_empty<B>::value is false. | If T is a non-union class type, T shall be a complete type. |
| template <class T> struct is_polymorphic; | T is a polymorphic class ([class.virtual]) | If T is a non-union class type, T shall be a complete type. |
| template <class T> struct is_abstract; | T is an abstract class ([class.abstract]) | If T is a non-union class type, T shall be a complete type. |
| template <class T> struct is_final; | T is a class type marked with the class-virt-specifier final (Clause [class]). [ Note: A union is a class type that can be marked with final. — end note ] | If T is a class type, T shall be a complete type. |
| template <class T> struct is_signed; | If is_arithmetic<T>::value is true, the same result as integral_constant<bool, T(-1) < T(0)>::value; otherwise, false | |
| template <class T> struct is_unsigned; | If is_arithmetic<T>::value is true, the same result as integral_constant<bool, T(0) < T(-1)>::value; otherwise, false | |
| template <class T, class... Args> struct is_constructible; | see below | T and all types in the parameter pack Args shall be complete types, (possibly cv-qualified) void, or arrays of unknown bound. |
| template <class T> struct is_default_constructible; | is_constructible<T>::value is true. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_copy_constructible; | For a referenceable type T, the same result as is_constructible<T, const T&>::value, otherwise false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_move_constructible; | For a referenceable type T, the same result as is_constructible<T, T&&>::value, otherwise false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T, class U> struct is_assignable; | The expression declval<T>() = declval<U>() is well-formed when treated as an unevaluated operand (Clause [expr]). Access checking is performed as if in a context unrelated to T and U. Only the validity of the immediate context of the assignment expression is considered. [ Note: The compilation of the expression can result in side effects such as the instantiation of class template specializations and function template specializations, the generation of implicitly-defined functions, and so on. Such side effects are not in the “immediate context” and can result in the program being ill-formed. — end note ] | T and U shall be complete types, (possibly cv-qualified) void, or arrays of unknown bound. |
| template <class T> struct is_copy_assignable; | For a referenceable type T, the same result as is_assignable<T&, const T&>::value, otherwise false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_move_assignable; | For a referenceable type T, the same result as is_assignable<T&, T&&>::value, otherwise false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_destructible; |
For reference types, is_destructible<T>::value is true. For incomplete types and function types, is_destructible<T>::value is false. For object types and given U equal to remove_all_extents_t<T>, if the expression std::declval<U&>().~U() is well-formed when treated as an unevaluated operand (Clause [expr]), then is_destructible<T>::value is true, otherwise it is false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T, class... Args> struct is_trivially_constructible; |
is_constructible<T, Args...>::value is true and the variable definition for is_constructible, as defined below, is known to call no operation that is not trivial ( [basic.types], [special]). | T and all types in the parameter pack Args shall be complete types, (possibly cv-qualified) void, or arrays of unknown bound. |
| template <class T> struct is_trivially_default_constructible; | is_trivially_constructible<T>::value is true. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_trivially_copy_constructible; | For a referenceable type T, the same result as is_trivially_constructible<T, const T&>::value, otherwise false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_trivially_move_constructible; | For a referenceable type T, the same result as is_trivially_constructible<T, T&&>::value, otherwise false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T, class U> struct is_trivially_assignable; | is_assignable<T, U>::value is true and the assignment, as defined by is_assignable, is known to call no operation that is not trivial ([basic.types], [special]). | T and U shall be complete types, (possibly cv-qualified) void, or arrays of unknown bound. |
| template <class T> struct is_trivially_copy_assignable; | For a referenceable type T, the same result as is_trivially_assignable<T&, const T&>::value, otherwise false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_trivially_move_assignable; | For a referenceable type T, the same result as is_trivially_assignable<T&, T&&>::value, otherwise false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_trivially_destructible; | is_destructible<T>::value is true and the indicated destructor is known to be trivial. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T, class... Args> struct is_nothrow_constructible; | is_constructible<T, Args...>::value is true and the variable definition for is_constructible, as defined below, is known not to throw any exceptions ([expr.unary.noexcept]). | T and all types in the parameter pack Args shall be complete types, (possibly cv-qualified) void, or arrays of unknown bound. |
| template <class T> struct is_nothrow_default_constructible; | is_nothrow_constructible<T>::value is true. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_nothrow_copy_constructible; | For a referenceable type T, the same result as is_nothrow_constructible<T, const T&>::value, otherwise false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_nothrow_move_constructible; | For a referenceable type T, the same result as is_nothrow_constructible<T, T&&>::value, otherwise false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T, class U> struct is_nothrow_assignable; | is_assignable<T, U>::value is true and the assignment is known not to throw any exceptions ([expr.unary.noexcept]). | T and U shall be complete types, (possibly cv-qualified) void, or arrays of unknown bound. |
| template <class T> struct is_nothrow_copy_assignable; | For a referenceable type T, the same result as is_nothrow_assignable<T&, const T&>::value, otherwise false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_nothrow_move_assignable; | For a referenceable type T, the same result as is_nothrow_assignable<T&, T&&>::value, otherwise false. | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct is_nothrow_destructible; | is_destructible<T>::value is true and the indicated destructor is known not to throw any exceptions ([expr.unary.noexcept]). | T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. |
| template <class T> struct has_virtual_destructor; | T has a virtual destructor ([class.dtor]) | If T is a non-union class type, T shall be a complete type. |
| Template | Value |
|
template <class T> struct alignment_of; |
alignof(T). Requires: alignof(T) shall be a valid expression ([expr.alignof]) |
| template <class T> struct rank; | If T names an array type, an integer value representing the number of dimensions of T; otherwise, 0. |
| template <class T, unsigned I = 0> struct extent; | If T is not an array type, or if it has rank less than or equal to I, or if I is 0 and T has type “array of unknown bound of U”, then 0; otherwise, the bound ([dcl.array]) of the I'th dimension of T, where indexing of I is zero-based |
| Template | Condition | Comments |
|
template <class T, class U> struct is_same; | T and U name the same type with the same cv-qualifications | |
| template <class Base, class Derived> struct is_base_of; | Base is a base class of Derived (Clause [class.derived]) without regard to cv-qualifiers or Base and Derived are not unions and name the same class type without regard to cv-qualifiers | If Base and Derived are non-union class types and are different types (ignoring possible cv-qualifiers) then Derived shall be a complete type. [ Note: Base classes that are private, protected, or ambiguous are, nonetheless, base classes. — end note ] |
| template <class From, class To> struct is_convertible; | see below | From and To shall be complete types, arrays of unknown bound, or (possibly cv-qualified) void types. |
| Template | Comments |
|
template <class T> struct remove_const; | The member typedef type shall name the same type as T except that any top-level const-qualifier has been removed. [ Example: remove_const_t<const volatile int> evaluates to volatile int, whereas remove_const_t<const int*> evaluates to const int*. — end example ] |
|
template <class T> struct remove_volatile; | The member typedef type shall name the same type as T except that any top-level volatile-qualifier has been removed. [ Example: remove_volatile_t<const volatile int> evaluates to const int, whereas remove_volatile_t<volatile int*> evaluates to volatile int*. — end example ] |
|
template <class T> struct remove_cv; | The member typedef type shall be the same as T except that any top-level cv-qualifier has been removed. [ Example: remove_cv_t<const volatile int> evaluates to int, whereas remove_cv_t<const volatile int*> evaluates to const volatile int*. — end example ] |
|
template <class T> struct add_const; | If T is a reference, function, or top-level const-qualified type, then type shall name the same type as T, otherwise T const. |
|
template <class T> struct add_volatile; | If T is a reference, function, or top-level volatile-qualified type, then type shall name the same type as T, otherwise T volatile. |
|
template <class T> struct add_cv; | The member typedef type shall name the same type as add_const_t<add_volatile_t<T>>. |
| Template | Comments |
|
template <class T> struct remove_reference; | If T has type “reference to T1” then the member typedef type shall name T1; otherwise, type shall name T. |
| template <class T> struct add_lvalue_reference; | If T names an object or function type then the member typedef type shall name T&; otherwise, if T names a type “rvalue reference to T1” then the member typedef type shall name T1&; otherwise, type shall name T. |
| template <class T> struct add_rvalue_reference; | If T names an object or function type then the member typedef type shall name T&&; otherwise, type shall name T. [ Note: This rule reflects the semantics of reference collapsing ([dcl.ref]). For example, when a type T names a type T1&, the type add_rvalue_reference_t<T> is not an rvalue reference. — end note ] |
| Template | Comments |
|
template <class T> struct make_signed; |
If T names a (possibly cv-qualified) signed integer
type ([basic.fundamental]) then the member typedef
type shall name the type T; otherwise,
if T names a (possibly cv-qualified) unsigned integer
type then type shall name the corresponding
signed integer type, with the same cv-qualifiers as T;
otherwise, type shall name the signed integer type with smallest
rank ([conv.rank]) for which
sizeof(T) == sizeof(type), with the same
cv-qualifiers as T. Requires: T shall be a (possibly cv-qualified) integral type or enumeration but not a bool type. |
|
template <class T> struct make_unsigned; |
If T names a (possibly cv-qualified) unsigned integer
type ([basic.fundamental]) then the member typedef
type shall name the type T; otherwise,
if T names a (possibly cv-qualified) signed integer
type then type shall name the corresponding
unsigned integer type, with the same cv-qualifiers as T;
otherwise, type shall name the unsigned integer type with smallest
rank ([conv.rank]) for which
sizeof(T) == sizeof(type), with the same
cv-qualifiers as T. Requires: T shall be a (possibly cv-qualified) integral type or enumeration but not a bool type. |
| Template | Comments |
|
template <class T> struct remove_extent; | If T names a type “array of U”, the member typedef type shall be U, otherwise T. [ Note: For multidimensional arrays, only the first array dimension is removed. For a type “array of const U”, the resulting type is const U. — end note ] |
|
template <class T> struct remove_all_extents; | If T is “multi-dimensional array of U”, the resulting member typedef type is U, otherwise T. |
| Template | Comments |
|
template <class T> struct remove_pointer; | If T has type “(possibly cv-qualified) pointer to T1” then the member typedef type shall name T1; otherwise, it shall name T. |
|
template <class T> struct add_pointer; | The member typedef type shall name the same type as remove_reference_t<T>*. |
| Template | Condition | Comments |
|
template <std::size_t Len, std::size_t Align = default-alignment> struct aligned_storage; | Len shall not be zero. Align shall be equal to alignof(T) for some type T or to default-alignment. | The value of default-alignment shall be the most stringent alignment requirement for any C++ object type whose size is no greater than Len ([basic.types]). The member typedef type shall be a POD type suitable for use as uninitialized storage for any object whose size is at most Len and whose alignment is a divisor of Align. |
| template <std::size_t Len, class... Types> struct aligned_union; | At least one type is provided. | The member typedef type shall be a POD type suitable for use as uninitialized storage for any object whose type is listed in Types; its size shall be at least Len. The static member alignment_value shall be an integral constant of type std::size_t whose value is the strictest alignment of all types listed in Types. |
| template <class T> struct decay; | Let U be remove_reference_t<T>. If is_array<U>::value is true, the member typedef type shall equal remove_extent_t<U>*. If is_function<U>::value is true, the member typedef type shall equal add_pointer_t<U>. Otherwise the member typedef type equals remove_cv_t<U>. [ Note: This behavior is similar to the lvalue-to-rvalue ([conv.lval]), array-to-pointer ([conv.array]), and function-to-pointer ([conv.func]) conversions applied when an lvalue expression is used as an rvalue, but also strips cv-qualifiers from class types in order to more closely model by-value argument passing. — end note ] | |
| template <bool B, class T = void> struct enable_if; | If B is true, the member typedef type shall equal T; otherwise, there shall be no member type. | |
| template <bool B, class T, class F> struct conditional; | If B is true, the member typedef type shall equal T. If B is false, the member typedef type shall equal F. | |
| template <class... T> struct common_type; | The member typedef type shall be defined as set out below. All types in the parameter pack T shall be complete or (possibly cv) void. A program may specialize this trait if at least one template parameter in the specialization is a user-defined type. [ Note: Such specializations are needed when only explicit conversions are desired among the template arguments. — end note ] | |
| template <class T> struct underlying_type; | T shall be an enumeration type ([dcl.enum]) | The member typedef type shall name the underlying type of T. |
| template <class Fn, class... ArgTypes> struct result_of<Fn(ArgTypes...)>; | Fn and all types in the parameter pack ArgTypes shall be complete types, (possibly cv-qualified) void, or arrays of unknown bound. | If the expression INVOKE(declval<Fn>(), declval<ArgTypes>()...) is well formed when treated as an unevaluated operand (Clause [expr]), the member typedef type shall name the type decltype(INVOKE(declval<Fn>(), declval<ArgTypes>()...)); otherwise, there shall be no member type. Access checking is performed as if in a context unrelated to Fn and ArgTypes. Only the validity of the immediate context of the expression is considered. [ Note: The compilation of the expression can result in side effects such as the instantiation of class template specializations and function template specializations, the generation of implicitly-defined functions, and so on. Such side effects are not in the “immediate context” and can result in the program being ill-formed. — end note ] |
| Type | Value of X | Value of Y |
| ratio_add<R1, R2> | R1::num * R2::den + | R1::den * R2::den |
| R2::num * R1::den | ||
| ratio_subtract<R1, R2> | R1::num * R2::den - | R1::den * R2::den |
| R2::num * R1::den | ||
| ratio_multiply<R1, R2> | R1::num * R2::num | R1::den * R2::den |
| ratio_divide<R1, R2> | R1::num * R2::den | R1::den * R2::num |
| Expression | Return type | Operational semantics |
| C1::rep | An arithmetic type or a class emulating an arithmetic type | The representation type of C1::duration. |
| C1::period | a specialization of ratio | The tick period of the clock in seconds. |
| C1::duration | chrono::duration<C1::rep, C1::period> | The duration type of the clock. |
| C1::time_point | chrono::time_point<C1> or chrono::time_point<C2, C1::duration> | The time_point type of the clock. C1 and C2 shall refer to the same epoch. |
| C1::is_steady | const bool | true if t1 <= t2 is always true and the time between clock ticks is constant, otherwise false. |
| C1::now() | C1::time_point | Returns a time_point object representing the current point in time. |
| Type | Name(s) | |||
| Macros: | NULL | CLOCKS_PER_SEC | ||
| Types: | size_t | clock_t | time_t | |
| Struct: | tm | |||
| Functions: | ||||
| asctime | clock | difftime | localtime | strftime |
| ctime | gmtime | mktime | time | |
| Subclause | Header(s) | |
| [char.traits] | Character traits | <string> |
| [string.classes] | String classes | <string> |
| <cctype> | ||
| <cwctype> | ||
| [c.strings] | Null-terminated sequence utilities | <cstring> |
| <cwchar> | ||
| <cstdlib> | ||
| <cuchar> | ||
| Expression | Return type | Assertion/note | Complexity |
| pre-/post-condition | |||
| X::char_type | charT | (described in [char.traits.typedefs]) | compile-time |
| X::int_type | (described in [char.traits.typedefs]) | compile-time | |
| X::off_type | (described in [char.traits.typedefs]) | compile-time | |
| X::pos_type | (described in [char.traits.typedefs]) | compile-time | |
| X::state_type | (described in [char.traits.typedefs]) | compile-time | |
| X::eq(c,d) | bool | yields: whether c is to be treated as equal to d. | constant |
| X::lt(c,d) | bool | yields: whether c is to be treated as less than d. | constant |
| X::compare(p,q,n) | int | yields: 0 if for each i in [0,n), X::eq(p[i],q[i]) is true; else, a negative value if, for some j in [0,n), X::lt(p[j],q[j]) is true and for each i in [0,j) X::eq(p[i],q[i]) is true; else a positive value. | linear |
| X::length(p) | std::size_t | yields: the smallest i such that X::eq(p[i],charT()) is true. | linear |
| X::find(p,n,c) | const X::char_type* | yields: the smallest q in [p,p+n) such that X::eq(*q,c) is true, zero otherwise. | linear |
| X::move(s,p,n) | X::char_type* | for each i in [0,n), performs X::assign(s[i],p[i]). Copies correctly even where the ranges [p,p+n) and [s,s+n) overlap. yields: s. | linear |
| X::copy(s,p,n) | X::char_type* | pre: p not in [s,s+n). yields: s. for each i in [0,n), performs X::assign(s[i],p[i]). | linear |
| X::assign(r,d) | (not used) | assigns r=d. | constant |
| X::assign(s,n,c) | X::char_type* | for each i in [0,n), performs X::assign(s[i],c). yields: s. | linear |
| X::not_eof(e) | int_type | yields: e if X::eq_int_type(e,X::eof()) is false, otherwise a value f such that X::eq_int_type(f,X::eof()) is false. | constant |
| X::to_char_type(e) | X::char_type | yields: if for some c, X::eq_int_type(e,X::to_int_type(c)) is true, c; else some unspecified value. | constant |
| X::to_int_type(c) | X::int_type | yields: some value e, constrained by the definitions of to_char_type and eq_int_type. | constant |
| X::eq_int_type(e,f) | bool | yields: for all c and d, X::eq(c,d) is equal to X::eq_int_type(X::to_int_type(c), X::to_int_type(d)); otherwise, yields true if e and f are both copies of X::eof(); otherwise, yields false if one of e and f is a copy of X::eof() and the other is not; otherwise the value is unspecified. | constant |
| X::eof() | X::int_type | yields: a value e such that X::eq_int_type(e,X::to_int_type(c)) is false for all values c. | constant |
| Element | Value |
| data() | a non-null pointer that is copyable and can have 0 added to it |
| size() | 0 |
| capacity() | an unspecified value |
| Element | Value |
| data() | points at the first element of an allocated copy of the array whose first element is pointed at by str.data() |
| size() | str.size() |
| capacity() | a value at least as large as size() |
| Element | Value |
| data() | points at the first element of an allocated copy of rlen consecutive elements of the string controlled by str beginning at position pos |
| size() | rlen |
| capacity() | a value at least as large as size() |
| Element | Value |
| data() | points at the first element of an allocated copy of the array whose first element is pointed at by s |
| size() | n |
| capacity() | a value at least as large as size() |
| Element | Value |
| data() | points at the first element of an allocated copy of the array whose first element is pointed at by s |
| size() | traits::length(s) |
| capacity() | a value at least as large as size() |
| Element | Value |
| data() | points at the first element of an allocated array of n elements, each storing the initial value c |
| size() | n |
| capacity() | a value at least as large as size() |
| Element | Value |
| data() | points at the first element of an allocated copy of the array whose first element is pointed at by the original value of str.data(). |
| size() | the original value of str.size() |
| capacity() | a value at least as large as size() |
| get_allocator() | alloc |
| Element | Value |
| data() | points at the first element of an allocated copy of the array whose first element is pointed at by str.data() |
| size() | str.size() |
| capacity() | a value at least as large as size() |
| Element | Value |
| data() | points at the array whose first element was pointed at by str.data() |
| size() | previous value of str.size() |
| capacity() | a value at least as large as size() |
| Condition | Return Value |
| size() < str.size() | < 0 |
| size() == str.size() | 0 |
| size() > str.size() | > 0 |
| Type | Name(s) | |||
| Functions: | ||||
| isalnum | isblank | isdigit | isprint | isupper |
| tolower | isalpha | isgraph | ispunct | isxdigit |
| toupper | iscntrl | islower | isspace | |
| Type | Name(s) | |||
| Macro: | WEOF | |||
| Types: | wctrans_t | wctype_t | wint_t | |
| Functions: | ||||
| iswalnum | iswctype | iswprint | iswxdigit | wctrans |
| iswalpha | iswdigit | iswpunct | towctrans | wctype |
| iswblank | iswgraph | iswspace | towlower | |
| iswcntrl | iswlower | iswupper | towupper | |
| Type | Name(s) | |||
| Macro: | NULL <cstring> | |||
| Type: | size_t <cstring> | |||
| Functions: | ||||
| memchr | strcat | strcspn | strncpy | strtok |
| memcmp | strchr | strerror | strpbrk | strxfrm |
| memcpy | strcmp | strlen | strrchr | |
| memmove | strcoll | strncat | strspn | |
| memset | strcpy | strncmp | strstr | |
| Type | Name(s) | |||
| Macros: | NULL | WCHAR_MAX | WCHAR_MIN | WEOF |
| Types: | mbstate_t | wint_t | size_t | tm |
| Functions: | ||||
| btowc | mbsinit | vwscanf | wcsncpy | wcstoull |
| fgetwc | mbsrtowcs | wcrtomb | wcspbrk | wcstoul |
| fgetws | putwchar | wcscat | wcsrchr | wcsxfrm |
| fputwc | putwc | wcschr | wcsrtombs | wctob |
| fputws | swprintf | wcscmp | wcsspn | wmemchr |
| fwide | swscanf | wcscoll | wcsstr | wmemcmp |
| fwprintf | ungetwc | wcscpy | wcstod | wmemcpy |
| fwscanf | vfwprintf | wcscspn | wcstof | wmemmove |
| getwchar | vfwscanf | wcsftime | wcstok | wmemset |
| getwc | vswprintf | wcslen | wcstold | wprintf |
| mbrlen | vswscanf | wcsncat | wcstoll | wscanf |
| mbrtowc | vwprintf | wcsncmp | wcstol | |
| Type | Name(s) | ||
| Macros: | MB_CUR_MAX | ||
| Functions: | |||
| atof | mblen | strtof | strtoul |
| atoi | mbtowc | strtol | strtoull |
| atol | mbstowcs | strtold | wctomb |
| atoll | strtod | strtoll | wcstombs |
| Type | Name(s) | |
| Macros: | __STDC_UTF_16__ | |
| __STDC_UTF_32__ | ||
| Functions: | mbrtoc16 | c16rtomb |
| mbrtoc32 | c32rtomb | |
| Subclause | Header(s) | |
| [locales] | Locales | <locale> |
| [locale.categories] | Standard locale Categories | |
| [locale.stdcvt] | Standard code conversion facets | <codecvt> |
| [c.locales] | C library locales | <clocale> |
| Category | Includes facets |
| collate | collate<char>, collate<wchar_t> |
| ctype | ctype<char>, ctype<wchar_t> |
| codecvt<char,char,mbstate_t> | |
| codecvt<char16_t,char,mbstate_t> | |
| codecvt<char32_t,char,mbstate_t> | |
| codecvt<wchar_t,char,mbstate_t> | |
| monetary | moneypunct<char>, moneypunct<wchar_t> |
| moneypunct<char,true>, moneypunct<wchar_t,true> | |
| money_get<char>, money_get<wchar_t> | |
| money_put<char>, money_put<wchar_t> | |
| numeric | numpunct<char>, numpunct<wchar_t> |
| num_get<char>, num_get<wchar_t> | |
| num_put<char>, num_put<wchar_t> | |
| time | time_get<char>, time_get<wchar_t> |
| time_put<char>, time_put<wchar_t> | |
| messages | messages<char>, messages<wchar_t> |
| Category | Includes facets |
| collate | collate_byname<char>, collate_byname<wchar_t> |
| ctype | ctype_byname<char>, ctype_byname<wchar_t> |
| codecvt_byname<char,char,mbstate_t> | |
| codecvt_byname<char16_t,char,mbstate_t> | |
| codecvt_byname<char32_t,char,mbstate_t> | |
| codecvt_byname<wchar_t,char,mbstate_t> | |
| monetary | moneypunct_byname<char,International> |
| moneypunct_byname<wchar_t,International> | |
| money_get<C,InputIterator> | |
| money_put<C,OutputIterator> | |
| numeric | numpunct_byname<char>, numpunct_byname<wchar_t> |
| num_get<C,InputIterator>, num_put<C,OutputIterator> | |
| time | time_get<char,InputIterator> |
| time_get_byname<char,InputIterator> | |
| time_get<wchar_t,InputIterator> | |
| time_get_byname<wchar_t,InputIterator> | |
| time_put<char,OutputIterator> | |
| time_put_byname<char,OutputIterator> | |
| time_put<wchar_t,OutputIterator> | |
| time_put_byname<wchar_t,OutputIterator> | |
| messages | messages_byname<char>, messages_byname<wchar_t> |
| Value | Meaning |
| ok | completed the conversion |
| partial | not all source characters converted |
| error | encountered a character in [from,from_end) that it could not convert |
| noconv | internT and externT are the same type, and input sequence is identical to converted sequence |
| Value | Meaning |
| ok | completed the sequence |
| partial | space for more than to_end-to destination elements was needed to terminate a sequence given the value of state |
| error | an unspecified error has occurred |
| noconv | no termination is needed for this state_type |
| State | stdio equivalent |
| basefield == oct | %o |
| basefield == hex | %X |
| basefield == 0 | %i |
| signed integral type | %d |
| unsigned integral type | %u |
| Type | Length modifier |
| short | h |
| unsigned short | h |
| long | l |
| unsigned long | l |
| long long | ll |
| unsigned long long | ll |
| double | l |
| long double | L |
| State | stdio equivalent |
| basefield == ios_base::oct | %o |
| (basefield == ios_base::hex) && !uppercase | %x |
| (basefield == ios_base::hex) | %X |
| for a signed integral type | %d |
| for an unsigned integral type | %u |
| State | stdio equivalent |
| floatfield == ios_base::fixed | %f |
| floatfield == ios_base::scientific && !uppercase | %e |
| floatfield == ios_base::scientific | %E |
| floatfield == (ios_base::fixed | ios_base::scientific) && !uppercase | %a |
| floatfield == (ios_base::fixed | ios_base::scientific) | %A |
| !uppercase | %g |
| otherwise | %G |
| Type | Length modifier |
| long | l |
| long long | ll |
| unsigned long | l |
| unsigned long long | ll |
| long double | L |
| otherwise | none |
| Type(s) | State | stdio equivalent |
| an integral type | flags & showpos | + |
| flags & showbase | # | |
| a floating-point type | flags & showpos | + |
| flags & showpoint | # |
| State | Location |
| adjustfield == ios_base::left | pad after |
| adjustfield == ios_base::right | pad before |
| adjustfield == internal and a sign occurs in the representation | pad after the sign |
| adjustfield == internal and representation after stage 1 began with 0x or 0X | pad after x or X |
| otherwise | pad before |
| date_order() | Format |
| no_order | "%m%d%y" |
| dmy | "%d%m%y" |
| mdy | "%m%d%y" |
| ymd | "%y%m%d" |
| ydm | "%y%d%m" |
| Type | Name(s) | ||
| Macros: | LC_ALL | LC_COLLATE | LC_CTYPE |
| LC_MONETARY | LC_NUMERIC | LC_TIME | |
| NULL | |||
| Struct: | lconv | ||
| Functions: | localeconv | setlocale | |
| fprintf | isprint | iswdigit | localeconv | tolower |
| fscanf | ispunct | iswgraph | mblen | toupper |
| isalnum | isspace | iswlower | mbstowcs | towlower |
| isalpha | isupper | iswprint | mbtowc | towupper |
| isblank | iswalnum | iswpunct | setlocale | wcscoll |
| iscntrl | iswalpha | iswspace | strcoll | wcstod |
| isdigit | iswblank | iswupper | strerror | wcstombs |
| isgraph | iswcntrl | iswxdigit | strtod | wcsxfrm |
| islower | iswctype | isxdigit | strxfrm | wctomb |
| Subclause | Header(s) | |
| [container.requirements] | Requirements | |
| [sequences] | Sequence containers | <array> |
| <deque> | ||
| <forward_list> | ||
| <list> | ||
| <vector> | ||
| [associative] | Associative containers | <map> |
| <set> | ||
| [unord] | Unordered associative containers | <unordered_map> |
| <unordered_set> | ||
| [container.adaptors] | Container adaptors | <queue> |
| <stack> | ||
| Expression | Return type | Operational | Assertion/note | Complexity |
| semantics | pre-/post-condition | |||
| X::value_type | T | Requires: T is Erasable from X (see [container.requirements.general], below) | compile time | |
| X::reference | T& | compile time | ||
| X::const_reference | const T& | compile time | ||
| X::iterator | iterator type whose value type is T | any iterator category that meets the forward iterator requirements. convertible to X::const_iterator. | compile time | |
| X::const_iterator | constant iterator type whose value type is T | any iterator category that meets the forward iterator requirements. | compile time | |
| X::difference_type | signed integer type | is identical to the difference type of X::iterator and X::const_iterator | compile time | |
| X::size_type | unsigned integer type | size_type can represent any non-negative value of difference_type | compile time | |
| X u; | post: u.empty() | constant | ||
| X() | post: X().empty() | constant | ||
| X(a) |
Requires: T is CopyInsertable
into X (see below). post: a == X(a). | linear | ||
| X u(a) X u = a; |
Requires: T is CopyInsertable
into X (see below). post: u == a | linear | ||
| X u(rv) X u = rv | post: u shall be equal to the value that rv had before this construction | (Note B) | ||
| a = rv | X& | All existing elements of a are either move assigned to or destroyed | a shall be equal to the value that rv had before this assignment | linear |
| (&a)->~X() | void | note: the destructor is applied to every element of a; any memory obtained is deallocated. | linear | |
| a.begin() | iterator; const_iterator for constant a | constant | ||
| a.end() | iterator; const_iterator for constant a | constant | ||
| a.cbegin() | const_iterator | const_cast<X const&>(a).begin(); | constant | |
| a.cend() | const_iterator | const_cast<X const&>(a).end(); | constant | |
| a == b | convertible to bool | == is an equivalence relation. equal(a.begin(), a.end(), b.begin(), b.end()) | Requires: T is EqualityComparable | Constant if a.size() != b.size(), linear otherwise |
| a != b | convertible to bool | Equivalent to: !(a == b) | linear | |
| a.swap(b) | void | exchanges the contents of a and b | (Note A) | |
| swap(a, b) | void | a.swap(b) | (Note A) | |
| r = a | X& | post: r == a. | linear | |
| a.size() | size_type | distance(a.begin(), a.end()) | constant | |
| a.max_size() | size_type | distance(begin(), end()) for the largest possible container | constant | |
| a.empty() | convertible to bool | a.begin() == a.end() | constant |
| Expression | Return type | Assertion/note | Complexity |
| pre-/post-condition | |||
| X::reverse_iterator | iterator type whose value type is T | reverse_iterator<iterator> | compile time |
| X::const_reverse_iterator | constant iterator type whose value type is T | reverse_iterator<const_iterator> | compile time |
| a.rbegin() | reverse_iterator; const_reverse_iterator for constant a | reverse_iterator(end()) | constant |
| a.rend() | reverse_iterator; const_reverse_iterator for constant a | reverse_iterator(begin()) | constant |
| a.crbegin() | const_reverse_iterator | const_cast<X const&>(a).rbegin() | constant |
| a.crend() | const_reverse_iterator | const_cast<X const&>(a).rend() | constant |
| Expression | Return type | Operational | Assertion/note | Complexity |
| semantics | pre-/post-condition | |||
| a < b | convertible to bool | lexicographical_compare( a.begin(), a.end(), b.begin(), b.end()) | pre: < is defined for values of T. < is a total ordering relationship. | linear |
| a > b | convertible to bool | b < a | linear | |
| a <= b | convertible to bool | !(a > b) | linear | |
| a >= b | convertible to bool | !(a < b) | linear |
| Expression | Return type | Assertion/note | Complexity |
| pre-/post-condition | |||
| allocator_type | A | Requires: allocator_type::value_type is the same as X::value_type. | compile time |
| get_- allocator() | A | constant | |
| X() X u; |
Requires: A is DefaultConstructible. post: u.empty() returns true, u.get_allocator() == A() | constant | |
| X(m) | post: u.empty() returns true, | constant | |
| X u(m); | u.get_allocator() == m | ||
| X(t, m) X u(t, m); |
Requires: T is CopyInsertable into X. post: u == t, u.get_allocator() == m | linear | |
| X(rv) X u(rv) |
Requires: move construction of A shall not exit via an exception. post: u shall have the same elements as rv had before this construction; the value of u.get_allocator() shall be the same as the value of rv.get_allocator() before this construction. | constant | |
| X(rv, m) X u(rv, m); |
Requires: T is
MoveInsertable into X. post: u shall have the same elements, or copies of the elements, that rv had before this construction, u.get_allocator() == m | constant if m == rv.get_allocator(), otherwise linear | |
| a = t | X& |
Requires: T is
CopyInsertable into X
and CopyAssignable. post: a == t | linear |
| a = rv | X& |
Requires: If allocator_- traits<allocator_type> ::propagate_on_container_- move_assignment::value is false, T is MoveInsertable into X and MoveAssignable. All existing elements of a are either move assigned to or destroyed. post: a shall be equal to the value that rv had before this assignment. | linear |
| a.swap(b) | void | exchanges the contents of a and b | constant |
| Expression | Return type | Assertion/note |
| pre-/post-condition | ||
|
X(n, t) X a(n, t) |
Requires: T shall be
CopyInsertable into X. post: distance(begin(), end()) == n Constructs a sequence container with n copies of t | |
| X(i, j) X a(i, j) |
Requires: T shall be EmplaceConstructible into X from *i.
For vector, if the iterator does
not meet the forward iterator requirements ([forward.iterators]), T
shall also be
MoveInsertable into X.
Each iterator in the range [i,j) shall be dereferenced exactly once. post: distance(begin(), end()) == distance(i, j) Constructs a sequence container equal to the range [i, j) | |
| X(il); | Equivalent to X(il.begin(), il.end()) | |
| a = il; | X& |
Requires: T is
CopyInsertable into X
and CopyAssignable.
Assigns the range [il.begin(),il.end()) into a. All existing
elements of a are either assigned to or destroyed. Returns: *this. |
| a.emplace(p, args); | iterator | Requires: T is EmplaceConstructible into X from args. For vector and deque, T is also MoveInsertable into X and MoveAssignable. Effects: Inserts an object of type T constructed with std::forward<Args>(args)... before p. |
| a.insert(p,t) | iterator |
Requires: T shall be
CopyInsertable into X. For vector and deque,
T shall also be CopyAssignable. Effects: Inserts a copy of t before p. |
| a.insert(p,rv) | iterator |
Requires: T shall be
MoveInsertable into X. For vector and deque,
T shall also be MoveAssignable. Effects: Inserts a copy of rv before p. |
| a.insert(p,n,t) | iterator |
Requires: T shall be
CopyInsertable into X
and CopyAssignable. Inserts n copies of t before p. |
| a.insert(p,i,j) | iterator |
Requires: T shall be EmplaceConstructible into X from *i. For vector, if the
iterator does not meet the forward iterator requirements ([forward.iterators]),
T shall also be
MoveInsertable into X and MoveAssignable.
Each iterator in the range [i,j) shall be dereferenced exactly once. pre: i and j are not iterators into a. Inserts copies of elements in [i, j) before p |
| a.insert(p, il); | iterator | a.insert(p, il.begin(), il.end()). |
| a.erase(q) | iterator |
Requires: For vector and deque,
T shall be MoveAssignable. Effects: Erases the element pointed to by q |
| a.erase(q1,q2) | iterator |
Requires: For vector and deque,
T shall be MoveAssignable. Effects: Erases the elements in the range [q1, q2). |
| a.clear() | void |
Destroys all elements in a. Invalidates all references, pointers, and
iterators referring to the elements of a and may invalidate the past-the-end iterator. post: a.empty() returns true. Complexity: Linear. |
| a.assign(i,j) | void |
Requires: T shall be EmplaceConstructible into X from *i
and assignable from *i. For vector, if the iterator does not
meet the forward iterator requirements ([forward.iterators]), T
shall also be
MoveInsertable into X. Each iterator in the range [i,j) shall be dereferenced exactly once. pre: i, j are not iterators into a. Replaces elements in a with a copy of [i, j). |
| a.assign(il) | void | a.assign(il.begin(), il.end()). |
| a.assign(n,t) | void |
Requires: T shall be
CopyInsertable into X
and CopyAssignable. pre: t is not a reference into a. Replaces elements in a with n copies of t. |
| Expression | Return type | Operational semantics | Container |
| a.front() | reference; const_reference for constant a | *a.begin() | basic_string, array, deque, forward_list, list, vector |
| a.back() | reference; const_reference for constant a |
{ auto tmp = a.end(); -- tmp; return *tmp; } | basic_string, array, deque, list, vector |
| a.emplace_- front(args) | void |
Prepends an object of type T constructed with std::forward<Args>(args).... Requires: T shall be EmplaceConstructible into X from args. | deque, forward_list, list |
| a.emplace_- back(args) | void |
Appends an object of type T constructed with std::forward<Args>(args).... Requires: T shall be EmplaceConstructible into X from args. For vector, T shall also be MoveInsertable into X. | deque, list, vector |
| a.push_front(t) | void |
Prepends a copy of t. Requires: T shall be CopyInsertable into X. | deque, forward_list, list |
| a.push_front(rv) | void |
Prepends a copy of rv. Requires: T shall be MoveInsertable into X. | deque, forward_list, list |
| a.push_back(t) | void |
Appends a copy of t. Requires: T shall be CopyInsertable into X. | basic_string, deque, list, vector |
| a.push_back(rv) | void |
Appends a copy of rv. Requires: T shall be MoveInsertable into X. | basic_string, deque, list, vector |
| a.pop_front() | void |
Destroys the first element. Requires: a.empty() shall be false. | deque, forward_list, list |
| a.pop_back() | void |
Destroys the last element. Requires: a.empty() shall be false. | basic_string, deque, list, vector |
| a[n] | reference; const_reference for constant a | *(a.begin() + n) | basic_string, array, deque, vector |
| a.at(n) | reference; const_reference for constant a | *(a.begin() + n) | basic_string, array, deque, vector |
| Expression | Return type | Assertion/note | Complexity |
| pre-/post-condition | |||
| X::key_type | Key | compile time | |
| mapped_type (map and multimap only) | T | compile time | |
| X::value_type (set and multiset only) | Key | Requires: value_type is Erasable from X | compile time |
| X::value_type (map and multimap only) | pair<const Key, T> | Requires: value_type is Erasable from X | compile time |
| X::key_compare | Compare | defaults to less<key_type> | compile time |
| X::value_compare | a binary predicate type | is the same as key_compare for set and multiset; is an ordering relation on pairs induced by the first component (i.e., Key) for map and multimap. | compile time |
| X(c) X a(c); |
Requires: key_compare is CopyConstructible. Effects: Constructs an empty container. Uses a copy of c as a comparison object. | constant | |
| X() X a; |
Requires: key_compare is DefaultConstructible. Effects: Constructs an empty container. Uses Compare() as a comparison object | constant | |
| X(i,j,c) X a(i,j,c); |
Requires: key_compare is CopyConstructible.
value_type is EmplaceConstructible into X from *i. Effects: Constructs an empty container and inserts elements from the range [i, j) into it; uses c as a comparison object. | N log N in general (N has the value distance(i, j)); linear if [i, j) is sorted with value_comp() | |
| X(i,j) X a(i,j); |
Requires: key_compare is DefaultConstructible.
value_type is EmplaceConstructible into X from *i. Effects: Same as above, but uses Compare() as a comparison object | same as above | |
| X(il); | Same as X(il.begin(), il.end()). | Same as X(il.begin(), il.end()). | |
| X(il,c); | Same as X(il.begin(), il.end(), c). | Same as X(il.begin(), il.end(), c). | |
| a = il | X& |
Requires: value_type is
CopyInsertable into X
and CopyAssignable. Effects: Assigns the range [il.begin(),il.end()) into a. All existing elements of a are either assigned to or destroyed. | N log N in general (where N has the value il.size() + a.size()); linear if [il.begin(),il.end()) is sorted with value_comp(). |
| a.key_comp() | X::key_compare | returns the comparison object out of which a was constructed. | constant |
| a.value_comp() | X::value_compare | returns an object of value_compare constructed out of the comparison object | constant |
| a_uniq. emplace(args) | pair<iterator, bool> |
Requires: value_type shall be EmplaceConstructible into X from args. Effects: Inserts a value_type object t constructed with std::forward<Args>(args)... if and only if there is no element in the container with key equivalent to the key of t. The bool component of the returned pair is true if and only if the insertion takes place, and the iterator component of the pair points to the element with key equivalent to the key of t. | logarithmic |
| a_eq. emplace(args) | iterator |
Requires: value_type shall be EmplaceConstructible into X from args. Effects: Inserts a value_type object t constructed with std::forward<Args>(args)... and returns the iterator pointing to the newly inserted element. If a range containing elements equivalent to t exists in a_eq, t is inserted at the end of that range. | logarithmic |
| a.emplace_hint(p, args) | iterator | equivalent to a.emplace( std::forward<Args>(args)...). Return value is an iterator pointing to the element with the key equivalent to the newly inserted element. The element is inserted as close as possible to the position just prior to p. | logarithmic in general, but amortized constant if the element is inserted right before p |
| a_uniq. insert(t) | pair<iterator, bool> |
Requires: If t is a non-const rvalue expression, value_type shall be
MoveInsertable into X; otherwise, value_type shall be
CopyInsertable into X. Effects: Inserts t if and only if there is no element in the container with key equivalent to the key of t. The bool component of the returned pair is true if and only if the insertion takes place, and the iterator component of the pair points to the element with key equivalent to the key of t. | logarithmic |
| a_eq.insert(t) | iterator |
Requires: If t is a non-const rvalue expression, value_type shall be
MoveInsertable into X; otherwise, value_type shall be
CopyInsertable into X. Effects: Inserts t and returns the iterator pointing to the newly inserted element. If a range containing elements equivalent to t exists in a_eq, t is inserted at the end of that range. | logarithmic |
| a.insert( p, t) | iterator |
Requires: If t is a non-const rvalue expression, value_type shall be
MoveInsertable into X; otherwise, value_type shall be
CopyInsertable into X. Effects: Inserts t if and only if there is no element with key equivalent to the key of t in containers with unique keys; always inserts t in containers with equivalent keys. Always returns the iterator pointing to the element with key equivalent to the key of t. t is inserted as close as possible to the position just prior to p. | logarithmic in general, but amortized constant if t is inserted right before p. |
| a.insert( i, j) | void |
Requires: value_type shall be EmplaceConstructible into X from *i. pre: i, j are not iterators into a. inserts each element from the range [i,j) if and only if there is no element with key equivalent to the key of that element in containers with unique keys; always inserts that element in containers with equivalent keys. | Nlog (a.size() + N) (N has the value distance(i, j) |
| a.insert(il) | void | Equivalent to a.insert(il.begin(), il.end()). | |
| a.erase(k) | size_type | erases all elements in the container with key equivalent to k. returns the number of erased elements. | log (a.size()) + a.count(k) |
| a.erase(q) | iterator | erases the element pointed to by q. Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns a.end(). | amortized constant |
| a.erase( q1, q2) | iterator | erases all the elements in the range [q1,q2). Returns an iterator pointing to the element pointed to by q2 prior to any elements being erased. If no such element exists, a.end() is returned. | log (a.size()) + N where N has the value distance(q1, q2). |
| a.clear() | void |
a.erase(a.begin(),a.end()) post: a.empty() returns true | linear in a.size(). |
| a.find(k) | iterator; const_iterator for constant a. | returns an iterator pointing to an element with the key equivalent to k, or a.end() if such an element is not found | logarithmic |
| a_tran. find(ke) | iterator; const_iterator for constant a_tran. | returns an iterator pointing to an element with key r such that !c(r, ke) && !c(ke, r), or a_tran.end() if such an element is not found | logarithmic |
| a.count(k) | size_type | returns the number of elements with key equivalent to k | log (a.size()) + a.count(k) |
| a_tran. count(ke) | size_type | returns the number of elements with key r such that !c(r, ke) && !c(ke, r) | log (a_tran.size()) + a_tran.count(ke) |
| a.lower_bound(k) | iterator; const_iterator for constant a. | returns an iterator pointing to the first element with key not less than k, or a.end() if such an element is not found. | logarithmic |
| a_tran. lower_bound(kl) | iterator; const_iterator for constant a_tran. | returns an iterator pointing to the first element with key r such that !c(r, kl), or a_tran.end() if such an element is not found. | logarithmic |
| a.upper_bound(k) | iterator; const_iterator for constant a. | returns an iterator pointing to the first element with key greater than k, or a.end() if such an element is not found. | logarithmic |
| a_tran. upper_bound(ku) | iterator; const_iterator for constant a_tran. | returns an iterator pointing to the first element with key r such that c(ku, r), or a_tran.end() if such an element is not found. | logarithmic |
| a.equal_range(k) | pair<iterator, iterator>; pair<const_iterator, const_iterator> for constant a. | equivalent to make_pair(a.lower_bound(k), a.upper_bound(k)). | logarithmic |
| a_tran. equal_range(ke) | pair<iterator, iterator>; pair<const_iterator, const_iterator> for constant a_tran. |
equivalent to make_pair( a_tran.lower_bound(ke), a_tran.upper_bound(ke)). | logarithmic |
| Expression | Return type | Assertion/note pre-/post-condition | Complexity |
| X::key_type | Key | compile time | |
| X::mapped_type (unordered_map and unordered_multimap only) | T | compile time | |
| X::value_type (unordered_set and unordered_multiset only) | Key | Requires: value_type is Erasable from X | compile time |
| X::value_type (unordered_map and unordered_multimap only) | pair<const Key, T> | Requires: value_type is Erasable from X | compile time |
| X::hasher | Hash | Hash shall be a unary function object type such that the expression hf(k) has type std::size_t. | compile time |
| X::key_equal | Pred | Pred shall be a binary predicate that takes two arguments of type Key. Pred is an equivalence relation. | compile time |
| X::local_iterator | An iterator type whose category, value type, difference type, and pointer and reference types are the same as X::iterator's. | A local_iterator object may be used to iterate through a single bucket, but may not be used to iterate across buckets. | compile time |
| X::const_local_iterator | An iterator type whose category, value type, difference type, and pointer and reference types are the same as X::const_iterator's. | A const_local_iterator object may be used to iterate through a single bucket, but may not be used to iterate across buckets. | compile time |
|
X(n, hf, eq) X a(n, hf, eq) | X | Requires: hasher and key_equal are CopyConstructible. Effects: Constructs an empty container with at least n buckets, using hf as the hash function and eq as the key equality predicate. | Ο(n) |
|
X(n, hf) X a(n, hf) | X | Requires: hasher is CopyConstructible and key_equal
is DefaultConstructible. Effects: Constructs an empty container with at least n buckets, using hf as the hash function and key_equal() as the key equality predicate. | Ο(n) |
|
X(n) X a(n) | X | Requires: hasher and key_equal are DefaultConstructible. Effects: Constructs an empty container with at least n buckets, using hasher() as the hash function and key_equal() as the key equality predicate. | Ο(n) |
|
X() X a | X | Requires: hasher and key_equal are DefaultConstructible. Effects: Constructs an empty container with an unspecified number of buckets, using hasher() as the hash function and key_equal() as the key equality predicate. | constant |
|
X(i, j, n, hf, eq) X a(i, j, n, hf, eq) | X | Requires: hasher and key_equal are CopyConstructible.
value_type is EmplaceConstructible into X from *i. Effects: Constructs an empty container with at least n buckets, using hf as the hash function and eq as the key equality predicate, and inserts elements from [i, j) into it. | Average case Ο(N) (N is distance(i, j)), worst case Ο(N2) |
|
X(i, j, n, hf) X a(i, j, n, hf) | X | Requires: hasher is CopyConstructible and key_equal
is DefaultConstructible.
value_type is EmplaceConstructible into X from *i. Effects: Constructs an empty container with at least n buckets, using hf as the hash function and key_equal() as the key equality predicate, and inserts elements from [i, j) into it. | Average case Ο(N) (N is distance(i, j)), worst case Ο(N2) |
|
X(i, j, n) X a(i, j, n) | X | Requires: hasher and key_equal are DefaultConstructible.
value_type is EmplaceConstructible into X from *i. Effects: Constructs an empty container with at least n buckets, using hasher() as the hash function and key_equal() as the key equality predicate, and inserts elements from [i, j) into it. | Average case Ο(N) (N is distance(i, j)), worst case Ο(N2) |
|
X(i, j) X a(i, j) | X | Requires: hasher and key_equal are DefaultConstructible.
value_type is EmplaceConstructible into X from *i. Effects: Constructs an empty container with an unspecified number of buckets, using hasher() as the hash function and key_equal() as the key equality predicate, and inserts elements from [i, j) into it. | Average case Ο(N) (N is distance(i, j)), worst case Ο(N2) |
| X(il) | X | Same as X(il.begin(), il.end()). | Same as X(il.begin(), il.end()). |
| X(il, n) | X | Same as X(il.begin(), il.end(), n). | Same as X(il.begin(), il.end(), n). |
| X(il, n, hf) | X | Same as X(il.begin(), il.end(), n, hf). | Same as X(il.begin(), il.end(), n, hf). |
| X(il, n, hf, eq) | X | Same as X(il.begin(), il.end(), n, hf, eq). | Same as X(il.begin(), il.end(), n, hf, eq). |
|
X(b) X a(b) | X | Copy constructor. In addition to the requirements of Table [tab:containers.container.requirements], copies the hash function, predicate, and maximum load factor. | Average case linear in b.size(), worst case quadratic. |
| a = b | X& | Copy assignment operator. In addition to the requirements of Table [tab:containers.container.requirements], copies the hash function, predicate, and maximum load factor. | Average case linear in b.size(), worst case quadratic. |
| a = il | X& | Requires: value_type is
CopyInsertable into X
and CopyAssignable. Effects: Assigns the range [il.begin(),il.end()) into a. All existing elements of a are either assigned to or destroyed. | Same as a = X(il). |
| b.hash_function() | hasher | Returns b's hash function. | constant |
| b.key_eq() | key_equal | Returns b's key equality predicate. | constant |
| a_uniq. emplace(args) | pair<iterator, bool> |
Requires: value_type shall be EmplaceConstructible into X from args. Effects: Inserts a value_type object t constructed with std::forward<Args>(args)... if and only if there is no element in the container with key equivalent to the key of t. The bool component of the returned pair is true if and only if the insertion takes place, and the iterator component of the pair points to the element with key equivalent to the key of t. |
Average case Ο(1), worst case Ο(a_uniq. size()). |
| a_eq.emplace(args) | iterator |
Requires: value_type shall be EmplaceConstructible into X from args. Effects: Inserts a value_type object t constructed with std::forward<Args>(args)... and returns the iterator pointing to the newly inserted element. |
Average case Ο(1), worst case Ο(a_eq. size()). |
| a.emplace_hint(p, args) | iterator |
Requires: value_type shall be EmplaceConstructible into X from args. Effects: Equivalent to a.emplace( std::forward<Args>(args)...). Return value is an iterator pointing to the element with the key equivalent to the newly inserted element. The const_iterator p is a hint pointing to where the search should start. Implementations are permitted to ignore the hint. | Average case Ο(1), worst case Ο(a. size()). |
| a_uniq.insert(t) | pair<iterator, bool> | Requires: If t is a non-const rvalue expression, value_type shall be
MoveInsertable into X; otherwise, value_type shall be
CopyInsertable into X. Effects: Inserts t if and only if there is no element in the container with key equivalent to the key of t. The bool component of the returned pair indicates whether the insertion takes place, and the iterator component points to the element with key equivalent to the key of t. | Average case Ο(1), worst case Ο(a_uniq. size()). |
| a_eq.insert(t) | iterator | Requires: If t is a non-const rvalue expression, value_type shall be
MoveInsertable into X; otherwise, value_type shall be
CopyInsertable into X. Effects: Inserts t, and returns an iterator pointing to the newly inserted element. | Average case Ο(1), worst case Ο(a_eq. size()). |
| a.insert(q, t) | iterator | Requires: If t is a non-const rvalue expression, value_type shall be
MoveInsertable into X; otherwise, value_type shall be
CopyInsertable into X. Effects: Equivalent to a.insert(t). Return value is an iterator pointing to the element with the key equivalent to that of t. The iterator q is a hint pointing to where the search should start. Implementations are permitted to ignore the hint. | Average case Ο(1), worst case Ο(a.size()). |
| a.insert(i, j) | void | Requires: value_type shall be EmplaceConstructible into X from *i. Pre: i and j are not iterators in a. Equivalent to a.insert(t) for each element in [i,j). | Average case Ο(N), where N is distance(i, j). Worst
case Ο(N * (a.size()) + N). |
| a.insert(il) | void | Same as a.insert(il.begin(), il.end()). | Same as a.insert( il.begin(), il.end()). |
| a.erase(k) | size_type | Erases all elements with key equivalent to k. Returns the number of elements erased. | Average case Ο(a.count(k)). Worst case Ο(a.size()). |
| a.erase(q) | iterator | Erases the element pointed to by q. Return value is the iterator immediately following q prior to the erasure. | Average case Ο(1), worst case Ο(a.size()). |
| a.erase(q1, q2) | iterator | Erases all elements in the range [q1, q2). Return value is the iterator immediately following the erased elements prior to the erasure. | Average case linear in distance(q1, q2), worst case Ο(a.size()). |
| a.clear() | void | Erases all elements in the container. Post: a.empty() returns true | Linear. |
| b.find(k) | iterator; const_iterator for const b. | Returns an iterator pointing to an element with key equivalent to k, or b.end() if no such element exists. | Average case Ο(1), worst case Ο(b.size()). |
| b.count(k) | size_type | Returns the number of elements with key equivalent to k. | Average case Ο(b.count(k)), worst case Ο(b.size()). |
| b.equal_range(k) | pair<iterator, iterator>; pair<const_iterator, const_iterator> for const b. | Returns a range containing all elements with keys equivalent to k. Returns make_pair(b.end(), b.end()) if no such elements exist. | Average case Ο(b.count(k)). Worst case Ο(b.size()). |
| b.bucket_count() | size_type | Returns the number of buckets that b contains. | Constant |
| b.max_bucket_count() | size_type | Returns an upper bound on the number of buckets that b might ever contain. | Constant |
| b.bucket(k) | size_type |
Pre: b.bucket_count() > 0. Returns the index of the bucket in which elements with keys equivalent to k would be found, if any such element existed. Post: the return value shall be in the range [0, b.bucket_count()). | Constant |
| b.bucket_size(n) | size_type | Pre: n shall be in the range [0, b.bucket_count()). Returns the number of elements in the n th bucket. | Ο(b.bucket_size(n)) |
| b.begin(n) | local_iterator; const_local_iterator for const b. | Pre: n shall be in the range [0, b.bucket_count()). b.begin(n) returns an iterator referring to the first element in the bucket. If the bucket is empty, then b.begin(n) == b.end(n). | Constant |
| b.end(n) | local_iterator; const_local_iterator for const b. | Pre: n shall be in the range [0, b.bucket_count()). b.end(n) returns an iterator which is the past-the-end value for the bucket. | Constant |
| b.cbegin(n) | const_local_iterator | Pre: n shall be in the range [0, b.bucket_count()). Note: [b.cbegin(n), b.cend(n)) is a valid range containing all of the elements in the n th bucket. | Constant |
| b.cend(n) | const_local_iterator | Pre: n shall be in the range [0, b.bucket_count()). | Constant |
| b.load_factor() | float | Returns the average number of elements per bucket. | Constant |
| b.max_load_factor() | float | Returns a positive number that the container attempts to keep the load factor less than or equal to. The container automatically increases the number of buckets as necessary to keep the load factor below this number. | Constant |
| a.max_load_factor(z) | void | Pre: z shall be positive. May change the container's maximum load factor, using z as a hint. | Constant |
| a.rehash(n) | void | Post: a.bucket_count() > a.size() / a.max_load_factor() and a.bucket_count() >= n. | Average case linear in a.size(), worst case quadratic. |
| a.reserve(n) | void | Same as a.rehash(ceil(n / a.max_load_factor())). | Average case linear in a.size(), worst case quadratic. |
| Subclause | Header(s) | |
| [iterator.requirements] | Requirements | |
| [iterator.primitives] | Iterator primitives | <iterator> |
| [predef.iterators] | Predefined iterators | |
| [stream.iterators] | Stream iterators | |
| Random Access | → Bidirectional | → Forward | → Input |
| → Output |
| Expression | Return type | Operational | Assertion/note |
| semantics | pre-/post-condition | ||
| *r | reference | pre: r is dereferenceable. | |
| ++r | X& |
| Expression | Return type | Operational | Assertion/note |
| semantics | pre-/post-condition | ||
| a != b | contextually convertible to bool | !(a == b) | pre: (a,b) is in the domain of ==. |
| *a | convertible to T |
pre: a is dereferenceable. The expression (void)*a, *a is equivalent to *a. If a == b and (a,b) is in the domain of == then *a is equivalent to *b. | |
| a->m | (*a).m | pre: a is dereferenceable. | |
| ++r | X& |
pre: r is dereferenceable. post: r is dereferenceable or r is past-the-end. post: any copies of the previous value of r are no longer required either to be dereferenceable or to be in the domain of ==. | |
| (void)r++ | equivalent to (void)++r | ||
| *r++ | convertible to T |
{ T tmp = *r; ++r; return tmp; } |
| Expression | Return type | Operational | Assertion/note |
| semantics | pre-/post-condition | ||
| *r = o | result is not used |
Remark: After this operation r is not required to be dereferenceable. post: r is incrementable. | |
| ++r | X& |
&r == &++r. Remark: After this operation r is not required to be dereferenceable. post: r is incrementable. | |
| r++ | convertible to const X& |
{ X tmp = r; ++r; return tmp; } |
Remark: After this operation r is not required to be dereferenceable. post: r is incrementable. |
| *r++ = o | result is not used |
Remark: After this operation r is not required to be dereferenceable. post: r is incrementable. |
| Expression | Return type | Operational | Assertion/note |
| semantics | pre-/post-condition | ||
| r++ | convertible to const X& |
{ X tmp = r; ++r; return tmp; } | |
| *r++ | reference |
| Expression | Return type | Operational | Assertion/note |
| semantics | pre-/post-condition | ||
| -- r | X& |
pre: there exists s such that r == ++s. post: r is dereferenceable. --(++r) == r. -- r == -- s implies r == s. &r == &-- r. | |
| r-- | convertible to const X& |
{ X tmp = r; -- r; return tmp; } | |
| *r-- | reference |
| Expression | Return type | Operational | Assertion/note |
| semantics | pre-/post-condition | ||
| r += n | X& |
{ difference_type m = n; if (m >= 0) while (m--) ++r; else while (m++) -- r; return r; } | |
| a + n n + a | X |
{ X tmp = a; return tmp += n; } | a + n == n + a. |
| r -= n | X& | return r += -n; | |
| a - n | X |
{ X tmp = a; return tmp -= n; } | |
| b - a | difference_type | return n |
pre: there exists a value n of type difference_type such that a + n == b. b == a + (b - a). |
| a[n] | convertible to reference | *(a + n) | |
| a < b | contextually convertible to bool | b - a > 0 | < is a total ordering relation |
| a > b | contextually convertible to bool | b < a | > is a total ordering relation opposite to <. |
| a >= b | contextually convertible to bool | !(a < b) | |
| a <= b | contextually convertible to bool. | !(a > b) |
| Subclause | Header(s) | |
| [alg.nonmodifying] | Non-modifying sequence operations | |
| [alg.modifying.operations] | Mutating sequence operations | <algorithm> |
| [alg.sorting] | Sorting and related operations | |
| [alg.c.library] | C library algorithms | <cstdlib> |
| Subclause | Header(s) | |
| [numeric.requirements] | Requirements | |
| [cfenv] | Floating-Point Environment | <cfenv> |
| [complex.numbers] | Complex Numbers | <complex> |
| [rand] | Random number generation | <random> |
| [numarray] | Numeric arrays | <valarray> |
| [numeric.ops] | Generalized numeric operations | <numeric> |
| [c.math] | C library | <cmath> |
| <ctgmath> | ||
| <tgmath.h> | ||
| <cstdlib> | ||
| Expression | Return type | Pre/post-condition | Complexity |
| S::result_type | T | T is an unsigned integer type ([basic.fundamental]) of at least 32 bits. | compile-time |
| S() | Creates a seed sequence with the same initial state as all other default-constructed seed sequences of type S. | constant | |
| S(ib,ie) | Creates a seed sequence having internal state that depends on some or all of the bits of the supplied sequence [ib,ie). | Ο(ie - ib) | |
| S(il) | Same as S(il.begin(), il.end()). | same as S(il.begin(), il.end()) | |
| q.generate(rb,re) | void | Does nothing if rb == re. Otherwise, fills the supplied sequence [rb,re) with 32-bit quantities that depend on the sequence supplied to the constructor and possibly also depend on the history of generate's previous invocations. | Ο(re - rb) |
| r.size() | size_t | The number of 32-bit units that would be copied by a call to r.param. | constant |
| r.param(ob) | void | Copies to the given destination a sequence of 32-bit units that can be provided to the constructor of a second object of type S, and that would reproduce in that second object a state indistinguishable from the state of the first object. | Ο(r.size()) |
| Expression | Return type | Pre/post-condition | Complexity |
| G::result_type | T | T is an unsigned integer type ([basic.fundamental]). | compile-time |
| g() | T | Returns a value in the closed interval [G::min(), G::max()]. | amortized constant |
| G::min() | T | Denotes the least value potentially returned by operator(). | compile-time |
| G::max() | T | Denotes the greatest value potentially returned by operator(). | compile-time |
| Expression | Return type | Pre/post-condition | Complexity |
| E() | Creates an engine with the same initial state as all other default-constructed engines of type E. | Ο(size of state) | |
| E(x) | Creates an engine that compares equal to x. | Ο(size of state) | |
| E(s) | Creates an engine with initial state determined by s. | Ο(size of state) | |
| E(q)274 | Creates an engine with an initial state that depends on a sequence produced by one call to q.generate. | same as complexity of q.generate called on a sequence whose length is size of state | |
| e.seed() | void | post: e == E(). | same as E() |
| e.seed(s) | void | post: e == E(s). | same as E(s) |
| e.seed(q) | void | post: e == E(q). | same as E(q) |
| e() | T | Advances e's state ei to ei+1 = TA(ei) and returns GA(ei). | per Table [tab:UniformRandomNumberGenerator] |
| e.discard(z) 275 | void | Advances e's state ei to ei+z by any means equivalent to z consecutive calls e(). | no worse than the complexity of z consecutive calls e() |
| x == y | bool | This operator is an equivalence relation. With Sx and Sy as the infinite sequences of values that would be generated by repeated future calls to x() and y(), respectively, returns true if Sx = Sy ; else returns false. | Ο(size of state) |
| x != y | bool | !(x == y). | Ο(size of state) |
| os << x | reference to the type of os | With os.fmtflags set to ios_base::dec|ios_base::left and the fill character set to the space character, writes to os the textual representation of x's current state. In the output, adjacent numbers are separated by one or more space characters. post: The os.fmtflags and fill character are unchanged. | Ο(size of state) |
| is >> v | reference to the type of is | With is.fmtflags set to ios_base::dec, sets v's state as determined by reading its textual representation from is. If bad input is encountered, ensures that v's state is unchanged by the operation and calls is.setstate(ios::failbit) (which may throw ios::failure [[iostate.flags]]). If a textual representation written via os << x was subsequently read via is >> v, then x == v provided that there have been no intervening invocations of x or of v. pre: is provides a textual representation that was previously written using an output stream whose imbued locale was the same as that of is, and whose type's template specialization arguments charT and traits were respectively the same as those of is. post: The is.fmtflags are unchanged. | Ο(size of state) |
| Expression | Return type | Pre/post-condition | Complexity |
| D::result_type | T | T is an arithmetic type ([basic.fundamental]). | compile-time |
| D::param_type | P | compile-time | |
| D() | Creates a distribution whose behavior is indistinguishable from that of any other newly default-constructed distribution of type D. | constant | |
| D(p) | Creates a distribution whose behavior is indistinguishable from that of a distribution newly constructed directly from the values used to construct p. | same as p's construction | |
| d.reset() | void | Subsequent uses of d do not depend on values produced by any engine prior to invoking reset. | constant |
| x.param() | P | Returns a value p such that D(p).param() == p. | no worse than the complexity of D(p) |
| d.param(p) | void | post: d.param() == p. | no worse than the complexity of D(p) |
| d(g) | T | With p = d.param(), the sequence of numbers returned by successive invocations with the same object g is randomly distributed according to the associated p(z |{p}) or P(zi |{p}) function. | amortized constant number of invocations of g |
| d(g,p) | T | The sequence of numbers returned by successive invocations with the same objects g and p is randomly distributed according to the associated p(z |{p}) or P(zi |{p}) function. | amortized constant number of invocations of g |
| x.min() | T | Returns glb. | constant |
| x.max() | T | Returns lub. | constant |
| x == y | bool | This operator is an equivalence relation. Returns true if x.param() == y.param() and S1 = S2 , where S1 and S2 are the infinite sequences of values that would be generated, respectively, by repeated future calls to x(g1) and y(g2) whenever g1 == g2. Otherwise returns false. | constant |
| x != y | bool | !(x == y). | same as x == y. |
| os << x | reference to the type of os | Writes to os a textual representation for the parameters and the additional internal data of x. post: The os.fmtflags and fill character are unchanged. | |
| is >> d | reference to the type of is | Restores from is the parameters and additional internal data of the lvalue d. If bad input is encountered, ensures that d is unchanged by the operation and calls is.setstate(ios::failbit) (which may throw ios::failure [[iostate.flags]]). pre: is provides a textual representation that was previously written using an os whose imbued locale and whose type's template specialization arguments charT and traits were the same as those of is. post: The is.fmtflags are unchanged. |
| Type | Name(s) | |||
| Macros: | ||||
| FP_FAST_FMA | FP_ILOGBNAN | FP_SUBNORMAL | HUGE_VALL | MATH_ERRNO |
| FP_FAST_FMAF | FP_INFINITE | FP_ZERO | INFINITY | MATH_ERREXCEPT |
| FP_FAST_FMAL | FP_NAN | HUGE_VAL | NAN | math_errhandling |
| FP_ILOGB0 | FP_NORMAL | HUGE_VALF | ||
| Types: | double_t | float_t | ||
| Math Functions: | ||||
| abs | cosh | fmod | logb | remquo |
| acos | erf | frexp | lrint | rint |
| acosh | erfc | hypot | lround | round |
| asin | exp2 | ilogb | modf | scalbln |
| asinh | exp | ldexp | nan | scalbn |
| atan | expm1 | lgamma | nanf | sin |
| atan2 | fabs | llrint | nanl | sinh |
| atanh | fdim | llround | nearbyint | sqrt |
| cbrt | floor | log | nextafter | tan |
| ceil | fma | log10 | nexttoward | tanh |
| copysign | fmax | log1p | pow | tgamma |
| cos | fmin | log2 | remainder | trunc |
| Classification/comparison Functions: | ||||
| fpclassify | isgreaterequal | islessequal | isnan | isunordered |
| isfinite | isinf | islessgreater | isnormal | signbit |
| isgreater | isless | |||
| Type | Name(s) | |
| Macro: | RAND_MAX | |
| Types: | ||
| div_t | ldiv_t | lldiv_t |
| Functions: | ||
| abs | ldiv | rand |
| div | llabs | srand |
| labs | lldiv | |
| Subclause | Header(s) | |
| [iostreams.requirements] | Requirements | |
| [iostream.forward] | Forward declarations | <iosfwd> |
| [iostream.objects] | Standard iostream objects | <iostream> |
| [iostreams.base] | Iostreams base classes | <ios> |
| [stream.buffers] | Stream buffers | <streambuf> |
| [iostream.format] | Formatting and manipulators | <istream> |
| <ostream> | ||
| <iomanip> | ||
| [string.streams] | String streams | <sstream> |
| [file.streams] | File streams | <fstream> |
| <cstdio> | ||
| <cinttypes> | ||
| Element | Effect(s) if set |
| boolalpha | insert and extract bool type in alphabetic format |
| dec | converts integer input or generates integer output in decimal base |
| fixed | generate floating-point output in fixed-point notation |
| hex | converts integer input or generates integer output in hexadecimal base |
| internal | adds fill characters at a designated internal point in certain generated output, or identical to right if no such point is designated |
| left | adds fill characters on the right (final positions) of certain generated output |
| oct | converts integer input or generates integer output in octal base |
| right | adds fill characters on the left (initial positions) of certain generated output |
| scientific | generates floating-point output in scientific notation |
| showbase | generates a prefix indicating the numeric base of generated integer output |
| showpoint | generates a decimal-point character unconditionally in generated floating-point output |
| showpos | generates a + sign in non-negative generated numeric output |
| skipws | skips leading whitespace before certain input operations |
| unitbuf | flushes output after each output operation |
| uppercase | replaces certain lowercase letters with their uppercase equivalents in generated output |
| Constant | Allowable values |
| adjustfield | left | right | internal |
| basefield | dec | oct | hex |
| floatfield | scientific | fixed |
| Element | Effect(s) if set |
| badbit | indicates a loss of integrity in an input or output sequence (such as an irrecoverable read error from a file); |
| eofbit | indicates that an input operation reached the end of an input sequence; |
| failbit | indicates that an input operation failed to read the expected characters, or that an output operation failed to generate the desired characters. |
| Element | Effect(s) if set |
| app | seek to end before each write |
| ate | open and seek to end immediately after opening |
| binary | perform input and output in binary mode (as opposed to text mode) |
| in | open for input |
| out | open for output |
| trunc | truncate an existing stream when opening |
| Element | Meaning |
| beg | request a seek (for subsequent input or output) relative to the beginning of the stream |
| cur | request a seek relative to the current position within the sequence |
| end | request a seek relative to the current end of the sequence |
| Expression | Return type | Operational | Assertion/note |
| semantics | pre-/post-condition | ||
| P(i) |
p == P(i) note: a destructor is assumed. | ||
|
P p(i); P p = i; | post: p == P(i). | ||
| P(o) | fpos | converts from offset | |
| O(p) | streamoff | converts to offset | P(O(p)) == p |
| p == q | convertible to bool | == is an equivalence relation | |
| p != q | convertible to bool | !(p == q) | |
|
q = p + o p += o | fpos | + offset | q - o == p |
|
q = p - o p -= o | fpos | - offset | q + o == p |
| o = p - q | streamoff | distance | q + o == p |
|
streamsize(o) O(sz) |
streamsize streamoff |
converts converts |
streamsize(O(sz)) == sz streamsize(O(sz)) == sz |
| Element | Value |
| rdbuf() | sb |
| tie() | 0 |
| rdstate() | goodbit if sb is not a null pointer, otherwise badbit. |
| exceptions() | goodbit |
| flags() | skipws | dec |
| width() | 0 |
| precision() | 6 |
| fill() | widen(' '); |
| getloc() | a copy of the value returned by locale() |
| iarray | a null pointer |
| parray | a null pointer |
| Element | Value |
| rdbuf() | unchanged |
| tie() | rhs.tie() |
| rdstate() | unchanged |
| exceptions() | rhs.exceptions() |
| flags() | rhs.flags() |
| width() | rhs.width() |
| precision() | rhs.precision() |
| fill() | rhs.fill() |
| getloc() | rhs.getloc() |
| Conditions | Result |
| (which & ios_base::in) == ios_base::in | positions the input sequence |
| (which & ios_base::out) == ios_base::out | positions the output sequence |
|
(which & (ios_base::in | ios_base::out)) == (ios_base::in) | ios_base::out)) and way == either ios_base::beg or ios_base::end | positions both the input and the output sequences |
| Otherwise | the positioning operation fails. |
| Condition | newoff Value |
| way == ios_base::beg | 0 |
| way == ios_base::cur | the next pointer minus the beginning pointer (xnext - xbeg). |
| way == ios_base::end | the high mark pointer minus the beginning pointer (high_mark - xbeg). |
| ios_base flag combination | stdio equivalent | ||||
| binary | in | out | trunc | app | |
| + | "w" | ||||
| + | + | "a" | |||
| + | "a" | ||||
| + | + | "w" | |||
| + | "r" | ||||
| + | + | "r+" | |||
| + | + | + | "w+" | ||
| + | + | + | "a+" | ||
| + | + | "a+" | |||
| + | + | "wb" | |||
| + | + | + | "ab" | ||
| + | + | "ab" | |||
| + | + | + | "wb" | ||
| + | + | "rb" | |||
| + | + | + | "r+b" | ||
| + | + | + | + | "w+b" | |
| + | + | + | + | "a+b" | |
| + | + | + | "a+b" | ||
| way Value | stdio Equivalent |
| basic_ios::beg | SEEK_SET |
| basic_ios::cur | SEEK_CUR |
| basic_ios::end | SEEK_END |
| Type | Name(s) | ||||
| Macros: | |||||
| BUFSIZ | FOPEN_MAX | SEEK_CUR | TMP_MAX | _IONBF | stdout |
| EOF | L_tmpnam | SEEK_END | _IOFBF | stderr | |
| FILENAME_MAX | NULL <cstdio> | SEEK_SET | _IOLBF | stdin | |
| Types: | FILE | fpos_t | size_t <cstdio> | ||
| Functions: | |||||
| clearerr | fopen | fsetpos | putchar | snprintf | vscanf |
| fclose | fprintf | ftell | puts | sprintf | vsnprintf |
| feof | fputc | fwrite | remove | sscanf | vsprintf |
| ferror | fputs | getc | rename | tmpfile | vsscanf |
| fflush | fread | getchar | rewind | tmpnam | |
| fgetc | freopen | perror | scanf | ungetc | |
| fgetpos | fscanf | printf | setbuf | vfprintf | |
| fgets | fseek | putc | setvbuf | vprintf | |
| Type | Name(s) | ||
| Macros: | |||
| PRI{d i o u x X}[FAST LEAST]{8 16 32 64} | |||
| PRI{d i o u x X}{MAX PTR} | |||
| SCN{d i o u x X}[FAST LEAST]{8 16 32 64} | |||
| SCN{d i o u x X}{MAX PTR} | |||
| Types: | imaxdiv_t | ||
| Functions: | |||
| abs | imaxabs | strtoimax | wcstoimax |
| div | imaxdiv | strtoumax | wcstoumax |
| Subclause | Header(s) | |
| [re.def] | Definitions | |
| [re.req] | Requirements | |
| [re.const] | Constants | |
| [re.badexp] | Exception type | |
| [re.traits] | Traits | |
| [re.regex] | Regular expression template | <regex> |
| [re.submatch] | Submatches | |
| [re.results] | Match results | |
| [re.alg] | Algorithms | |
| [re.iter] | Iterators | |
| [re.grammar] | Grammar | |
| Expression | Return type | Assertion/note pre-/post-condition |
| X::char_type | charT | The character container type used in the implementation of class template basic_regex. |
| X::string_type | std::basic_string<charT> | |
| X::locale_type | A copy constructible type | A type that represents the locale used by the traits class. |
| X::char_class_type | A bitmask type ([bitmask.types]). | A bitmask type representing a particular character classification. |
| X::length(p) | std::size_t | Yields the smallest i such that p[i] == 0. Complexity is linear in i . |
| v.translate(c) | X::char_type | Returns a character such that for any character d that is to be considered equivalent to c then v.translate(c) == v.translate(d). |
| v.translate_nocase(c) | X::char_type | For all characters C that are to be considered equivalent to c when comparisons are to be performed without regard to case, then v.translate_nocase(c) == v.translate_nocase(C). |
| v.transform(F1, F2) | X::string_type | Returns a sort key for the character sequence designated by the iterator range [F1,F2) such that if the character sequence [G1,G2) sorts before the character sequence [H1,H2) then v.transform(G1, G2) < v.transform(H1, H2). |
| v.transform_primary(F1, F2) | X::string_type | Returns a sort key for the character sequence designated by the iterator range [F1,F2) such that if the character sequence [G1,G2) sorts before the character sequence [H1,H2) when character case is not considered then v.transform_primary(G1, G2) < v.transform_primary(H1, H2). |
| v.lookup_collatename(F1, F2) | X::string_type | Returns a sequence of characters that represents the collating element consisting of the character sequence designated by the iterator range [F1,F2). Returns an empty string if the character sequence is not a valid collating element. |
| v.lookup_classname(F1, F2, b) | X::char_class_type | Converts the character sequence designated by the iterator range [F1,F2) into a value of a bitmask type that can subsequently be passed to isctype. Values returned from lookup_classname can be bitwise or'ed together; the resulting value represents membership in either of the corresponding character classes. If b is true, the returned bitmask is suitable for matching characters without regard to their case. Returns 0 if the character sequence is not the name of a character class recognized by X. The value returned shall be independent of the case of the characters in the sequence. |
| v.isctype(c, cl) | bool | Returns true if character c is a member of one of the character classes designated by cl, false otherwise. |
| v.value(c, I) | int | Returns the value represented by the digit c in base I if the character c is a valid digit in base I; otherwise returns -1. [ Note: The value of I will only be 8, 10, or 16. — end note ] |
| u.imbue(loc) | X::locale_type | Imbues u with the locale loc and returns the previous locale used by u if any. |
| v.getloc() | X::locale_type | Returns the current locale used by v, if any. |
| Element | Effect(s) if set |
| icase | Specifies that matching of regular expressions against a character container sequence shall be performed without regard to case. |
| nosubs | Specifies that no sub-expressions shall be considered to be marked, so that when a regular expression is matched against a character container sequence, no sub-expression matches shall be stored in the supplied match_results structure. |
| optimize | Specifies that the regular expression engine should pay more attention to the speed with which regular expressions are matched, and less to the speed with which regular expression objects are constructed. Otherwise it has no detectable effect on the program output. |
| collate | Specifies that character ranges of the form "[a-b]" shall be locale sensitive. |
| ECMAScript | Specifies that the grammar recognized by the regular expression engine shall be that used by ECMAScript in ECMA-262, as modified in [re.grammar]. |
| basic | Specifies that the grammar recognized by the regular expression engine shall be that used by basic regular expressions in POSIX, Base Definitions and Headers, Section 9, Regular Expressions. |
| extended | Specifies that the grammar recognized by the regular expression engine shall be that used by extended regular expressions in POSIX, Base Definitions and Headers, Section 9, Regular Expressions. |
| awk | Specifies that the grammar recognized by the regular expression engine shall be that used by the utility awk in POSIX. |
| grep | Specifies that the grammar recognized by the regular expression engine shall be that used by the utility grep in POSIX. |
| egrep | Specifies that the grammar recognized by the regular expression engine shall be that used by the utility grep when given the -E option in POSIX. |
| Element | Effect(s) if set |
| match_not_bol |
The first character in the sequence [first,last) shall be treated
as though it is not at the beginning of a line, so the character
^ in the regular expression shall not match [first,first).
|
| match_not_eol |
The last character in the sequence [first,last) shall be treated
as though it is not at the end of a line, so the character
"$" in the regular expression shall not match [last,last).
|
| match_not_bow |
The expression "\\b" shall not match the
sub-sequence [first,first).
|
| match_not_eow |
The expression "\\b" shall not match the
sub-sequence [last,last).
|
| match_any | If more than one match is possible then any match is an acceptable result. |
| match_not_null | The expression shall not match an empty sequence. |
| match_continuous | The expression shall only match a sub-sequence that begins at first. |
| match_prev_avail |
--first is a valid iterator position. When this flag is
set the flags match_not_bol and match_not_bow shall be ignored by the
regular expression algorithms [re.alg] and iterators [re.iter].
|
| format_default | When a regular expression match is to be replaced by a new string, the new string shall be constructed using the rules used by the ECMAScript replace function in ECMA-262, part 15.5.4.11 String.prototype.replace. In addition, during search and replace operations all non-overlapping occurrences of the regular expression shall be located and replaced, and sections of the input that did not match the expression shall be copied unchanged to the output string. |
| format_sed | When a regular expression match is to be replaced by a new string, the new string shall be constructed using the rules used by the sed utility in POSIX. |
| format_no_copy | During a search and replace operation, sections of the character container sequence being searched that do not match the regular expression shall not be copied to the output string. |
| format_first_only | When specified during a search and replace operation, only the first occurrence of the regular expression shall be replaced. |
| Value | Error condition |
| error_collate | The expression contained an invalid collating element name. |
| error_ctype | The expression contained an invalid character class name. |
| error_escape | The expression contained an invalid escaped character, or a trailing escape. |
| error_backref | The expression contained an invalid back reference. |
| error_brack |
The expression contained mismatched [ and ]. |
| error_paren |
The expression contained mismatched ( and ). |
| error_brace |
The expression contained mismatched { and } |
| error_badbrace |
The expression contained an invalid range in a {} expression. |
| error_range |
The expression contained an invalid character range, such as
[b-a] in most encodings. |
| error_space | There was insufficient memory to convert the expression into a finite state machine. |
| error_badrepeat |
One of *?+{ was not preceded by a valid regular expression. |
| error_complexity | The complexity of an attempted match against a regular expression exceeded a pre-set level. |
| error_stack | There was insufficient memory to determine whether the regular expression could match the specified character sequence. |
| Narrow character name | Wide character name | Corresponding ctype_base::mask value |
| "alnum" | L"alnum" | ctype_base::alnum |
| "alpha" | L"alpha" | ctype_base::alpha |
| "blank" | L"blank" | ctype_base::blank |
| "cntrl" | L"cntrl" | ctype_base::cntrl |
| "digit" | L"digit" | ctype_base::digit |
| "d" | L"d" | ctype_base::digit |
| "graph" | L"graph" | ctype_base::graph |
| "lower" | L"lower" | ctype_base::lower |
| "print" | L"print" | ctype_base::print |
| "punct" | L"punct" | ctype_base::punct |
| "space" | L"space" | ctype_base::space |
| "s" | L"s" | ctype_base::space |
| "upper" | L"upper" | ctype_base::upper |
| "w" | L"w" | ctype_base::alnum |
| "xdigit" | L"xdigit" | ctype_base::xdigit |
| Element | Value |
| ready() | m.ready() |
| size() | m.size() |
| str(n) | m.str(n) for all integers n < m.size() |
| prefix() | m.prefix() |
| suffix() | m.suffix() |
| (*this)[n] | m[n] for all integers n < m.size() |
| length(n) | m.length(n) for all integers n < m.size() |
| position(n) | m.position(n) for all integers n < m.size() |
| Element | Value |
| m.size() | 1 + e.mark_count() |
| m.empty() | false |
| m.prefix().first | first |
| m.prefix().second | first |
| m.prefix().matched | false |
| m.suffix().first | last |
| m.suffix().second | last |
| m.suffix().matched | false |
| m[0].first | first |
| m[0].second | last |
| m[0].matched | true |
| m[n].first | For all integers 0 < n < m.size(), the start of the sequence that matched sub-expression n. Alternatively, if sub-expression n did not participate in the match, then last. |
| m[n].second | For all integers 0 < n < m.size(), the end of the sequence that matched sub-expression n. Alternatively, if sub-expression n did not participate in the match, then last. |
| m[n].matched | For all integers 0 < n < m.size(), true if sub-expression n participated in the match, false otherwise. |
| Element | Value |
| m.size() | 1 + e.mark_count() |
| m.empty() | false |
| m.prefix().first | first |
| m.prefix().second | m[0].first |
| m.prefix().matched | m.prefix().first != m.prefix().second |
| m.suffix().first | m[0].second |
| m.suffix().second | last |
| m.suffix().matched | m.suffix().first != m.suffix().second |
| m[0].first | The start of the sequence of characters that matched the regular expression |
| m[0].second | The end of the sequence of characters that matched the regular expression |
| m[0].matched | true |
| m[n].first | For all integers 0 < n < m.size(), the start of the sequence that matched sub-expression n. Alternatively, if sub-expression n did not participate in the match, then last. |
| m[n].second | For all integers 0 < n < m.size(), the end of the sequence that matched sub-expression n. Alternatively, if sub-expression n did not participate in the match, then last . |
| m[n].matched | For all integers 0 < n < m.size(), true if sub-expression n participated in the match, false otherwise. |
| Subclause | Header(s) | |
| [atomics.order] | Order and Consistency | |
| [atomics.lockfree] | Lock-free Property | |
| [atomics.types.generic] | Atomic Types | <atomic> |
| [atomics.types.operations] | Operations on Atomic Types | |
| [atomics.flag] | Flag Type and Operations | |
| [atomics.fences] | Fences | |
| Named type | Integral argument type |
| atomic_char | char |
| atomic_schar | signed char |
| atomic_uchar | unsigned char |
| atomic_short | short |
| atomic_ushort | unsigned short |
| atomic_int | int |
| atomic_uint | unsigned int |
| atomic_long | long |
| atomic_ulong | unsigned long |
| atomic_llong | long long |
| atomic_ullong | unsigned long long |
| atomic_char16_t | char16_t |
| atomic_char32_t | char32_t |
| atomic_wchar_t | wchar_t |
| Atomic typedef | <inttypes.h> type |
| atomic_int_least8_t | int_least8_t |
| atomic_uint_least8_t | uint_least8_t |
| atomic_int_least16_t | int_least16_t |
| atomic_uint_least16_t | uint_least16_t |
| atomic_int_least32_t | int_least32_t |
| atomic_uint_least32_t | uint_least32_t |
| atomic_int_least64_t | int_least64_t |
| atomic_uint_least64_t | uint_least64_t |
| atomic_int_fast8_t | int_fast8_t |
| atomic_uint_fast8_t | uint_fast8_t |
| atomic_int_fast16_t | int_fast16_t |
| atomic_uint_fast16_t | uint_fast16_t |
| atomic_int_fast32_t | int_fast32_t |
| atomic_uint_fast32_t | uint_fast32_t |
| atomic_int_fast64_t | int_fast64_t |
| atomic_uint_fast64_t | uint_fast64_t |
| atomic_intptr_t | intptr_t |
| atomic_uintptr_t | uintptr_t |
| atomic_size_t | size_t |
| atomic_ptrdiff_t | ptrdiff_t |
| atomic_intmax_t | intmax_t |
| atomic_uintmax_t | uintmax_t |
| Key | Op | Computation | Key | Op | Computation |
| add | + | addition | sub | - | subtraction |
| or | | | bitwise inclusive or | xor | ^ | bitwise exclusive or |
| and | & | bitwise and |
| Subclause | Header(s) | |
| [thread.req] | Requirements | |
| [thread.threads] | Threads | <thread> |
| [thread.mutex] | Mutual exclusion | <mutex> |
| <shared_mutex> | ||
| [thread.condition] | Condition variables | <condition_variable> |
| [futures] | Futures | <future> |
| assert | HUGE_VAL | NULL <cstring> | SIGINT | va_end |
| BUFSIZ | LC_ALL | NULL <ctime> | SIGSEGV | va_start |
| CLOCKS_PER_SEC | LC_COLLATE | NULL <cwchar> | SIGTERM | WCHAR_MAX |
| EDOM | LC_CTYPE | offsetof | SIG_DFL | WCHAR_MIN |
| EILSEQ | LC_MONETARY | RAND_MAX | SIG_ERR | WEOF <cwchar> |
| EOF | LC_NUMERIC | SEEK_CUR | SIG_IGN | WEOF <cwctype> |
| ERANGE | LC_TIME | SEEK_END | stderr | _IOFBF |
| errno | L_tmpnam | SEEK_SET | stdin | _IOLBF |
| EXIT_FAILURE | MB_CUR_MAX | setjmp | stdout | _IONBF |
| EXIT_SUCCESS | NULL <clocale> | SIGABRT | TMP_MAX | |
| FILENAME_MAX | NULL <cstddef> | SIGFPE | va_arg | |
| FOPEN_MAX | NULL <cstdlib> | SIGILL | va_copy |
| CHAR_BIT | FLT_DIG | INT_MIN | MB_LEN_MAX |
| CHAR_MAX | FLT_EPSILON | LDBL_DIG | SCHAR_MAX |
| CHAR_MIN | FLT_MANT_DIG | LDBL_EPSILON | SCHAR_MIN |
| DBL_DIG | FLT_MAX | LDBL_MANT_DIG | SHRT_MAX |
| DBL_EPSILON | FLT_MAX_10_EXP | LDBL_MAX | SHRT_MIN |
| DBL_MANT_DIG | FLT_MAX_EXP | LDBL_MAX_10_EXP | UCHAR_MAX |
| DBL_MAX | FLT_MIN | LDBL_MAX_EXP | UINT_MAX |
| DBL_MAX_10_EXP | FLT_MIN_10_EXP | LDBL_MIN | ULONG_MAX |
| DBL_MAX_EXP | FLT_MIN_EXP | LDBL_MIN_10_EXP | USHRT_MAX |
| DBL_MIN | FLT_RADIX | LDBL_MIN_EXP | |
| DBL_MIN_10_EXP | FLT_ROUNDS | LONG_MAX | |
| DBL_MIN_EXP | INT_MAX | LONG_MIN |
| clock_t | ldiv_t | size_t <cstdio> | va_list |
| div_t | mbstate_t | size_t <cstdlib> | wctrans_t |
| FILE | ptrdiff_t | size_t <cstring> | wctype_t |
| fpos_t | sig_atomic_t | size_t <ctime> | wint_t <cwchar> |
| jmp_buf | size_t <cstddef> | time_t | wint_t <cwctype> |
| abort | fmod | iswalnum | modf | strlen | wcscat |
| abs | fopen | iswalpha | perror | strncat | wcschr |
| acos | fprintf | iswcntrl | pow | strncmp | wcscmp |
| asctime | fputc | iswctype | printf | strncpy | wcscoll |
| asin | fputs | iswdigit | putc | strpbrk | wcscpy |
| atan | fputwc | iswgraph | putchar | strrchr | wcscspn |
| atan2 | fputws | iswlower | puts | strspn | wcsftime |
| atexit | fread | iswprint | putwc | strstr | wcslen |
| atof | free | iswpunct | putwchar | strtod | wcsncat |
| atoi | freopen | iswspace | qsort | strtok | wcsncmp |
| atol | frexp | iswupper | raise | strtol | wcsncpy |
| bsearch | fscanf | iswxdigit | rand | strtoul | wcspbrk |
| btowc | fseek | isxdigit | realloc | strxfrm | wcsrchr |
| calloc | fsetpos | labs | remove | swprintf | wcsrtombs |
| ceil | ftell | ldexp | rename | swscanf | wcsspn |
| clearerr | fwide | ldiv | rewind | system | wcsstr |
| clock | fwprintf | localeconv | scanf | tan | wcstod |
| cos | fwrite | localtime | setbuf | tanh | wcstok |
| cosh | fwscanf | log | setlocale | time | wcstol |
| ctime | getc | log10 | setvbuf | tmpfile | wcstombs |
| difftime | getchar | longjmp | signal | tmpnam | wcstoul |
| div | getenv | malloc | sin | tolower | wcsxfrm |
| exit | getwc | mblen | sinh | toupper | wctob |
| exp | getwchar | mbrlen | sprintf | towctrans | wctomb |
| fabs | gmtime | mbrtowc | sqrt | towlower | wctrans |
| fclose | isalnum | mbsinit | srand | towupper | wctype |
| feof | isalpha | mbsrtowcs | sscanf | ungetc | wmemchr |
| ferror | iscntrl | mbstowcs | strcat | ungetwc | wmemcmp |
| fflush | isdigit | mbtowc | strchr | vfprintf | wmemcpy |
| fgetc | isgraph | memchr | strcmp | vfwprintf | wmemmove |
| fgetpos | islower | memcmp | strcoll | vprintf | wmemset |
| fgets | isprint | memcpy | strcpy | vsprintf | wprintf |
| fgetwc | ispunct | memmove | strcspn | vswprintf | wscanf |
| fgetws | isspace | memset | strerror | vwprintf | |
| floor | isupper | mktime | strftime | wcrtomb |
| <assert.h> | <inttypes.h> | <signal.h> | <stdio.h> | <wchar.h> |
| <complex.h> | <iso646.h> | <stdalign.h> | <stdlib.h> | <wctype.h> |
| <ctype.h> | <limits.h> | <stdarg.h> | <string.h> | |
| <errno.h> | <locale.h> | <stdbool.h> | <tgmath.h> | |
| <fenv.h> | <math.h> | <stddef.h> | <time.h> | |
| <float.h> | <setjmp.h> | <stdint.h> | <uchar.h> |
| Element | Value |
| strmode | dynamic |
| alsize | alsize_arg |
| palloc | a null pointer |
| pfree | a null pointer |
| Element | Value |
| strmode | dynamic |
| alsize | an unspecified value |
| palloc | palloc_arg |
| pfree | pfree_arg |
| Element | Value |
| strmode | 0 |
| alsize | an unspecified value |
| palloc | a null pointer |
| pfree | a null pointer |
| Conditions | Result |
| (which & ios::in) != 0 | positions the input sequence |
| (which & ios::out) != 0 | positions the output sequence |
|
(which & (ios::in | ios::out)) == (ios::in | ios::out)) and way == either ios::beg or ios::end | positions both the input and the output sequences |
| Otherwise | the positioning operation fails. |
| Condition | newoff Value |
| way == ios::beg | 0 |
| way == ios::cur | the next pointer minus the beginning pointer (xnext - xbeg). |
| way == ios::end | seekhigh minus the beginning pointer (seekhigh - xbeg). |