Alternative  Primary  Alternative  Primary  Alternative  Primary 
<%  {  and  &&  and_eq  &= 
%>  }  bitor    or_eq  = 
<:  [  or    xor_eq  ^= 
:>  ]  xor  ^  not  ! 
%:  #  compl  ~  not_eq  != 
%:%:  ##  bitand  & 
00A8  00AA  00AD  00AF  00B200B5 
00B700BA  00BC00BE  00C000D6  00D800F6  00F800FF 
0100167F  1681180D  180F1FFF  
200B200D  202A202E  203F2040  2054  2060206F 
2070218F  246024FF  27762793  2C002DFF  2E802FFF 
30043007  3021302F  3031D7FF  
F900FD3D  FD40FDCF  FDF0FE44  FE47FFFD  
100001FFFD  200002FFFD  300003FFFD  400004FFFD  500005FFFD 
600006FFFD  700007FFFD  800008FFFD  900009FFFD  A0000AFFFD 
B0000BFFFD  C0000CFFFD  D0000DFFFD  E0000EFFFD 
0300036F  1DC01DFF  20D020FF  FE20FE2F 
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 
and  and_eq  bitand  bitor  compl  not 
not_eq  or  or_eq  xor  xor_eq 
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 
newline  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 cvqualifier  <  const 
no cvqualifier  <  volatile 
no cvqualifier  <  const volatile 
const  <  const volatile 
volatile  <  const volatile 
Specifier(s)  Type 
typename  the type named 
simpletemplateid  the type as defined in [temp.names] 
templatename  placeholder for a type to be deduced 
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(auto)  placeholder for a type to be deduced 
decltype(expression)  the type as defined below 
Subclause  Expression  As member function  As nonmember 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  
Lvaluetorvalue conversion  [conv.lval]  
Arraytopointer conversion  Lvalue Transformation  [conv.array]  
Functiontopointer conversion  Exact Match  [conv.func]  
Qualification conversions  [conv.qual]  
Function pointer conversion  Qualification Adjustment  [conv.fctptr]  
Integral promotions  [conv.prom]  
Floatingpoint promotion  Promotion  Promotion  [conv.fpprom] 
Integral conversions  [conv.integral]  
Floatingpoint conversions  [conv.double]  
Floatingintegral conversions  [conv.fpint]  
Pointer conversions  Conversion  Conversion  [conv.ptr] 
Pointer to member conversions  [conv.mem]  
Boolean conversions  [conv.bool] 
Operator  Value when parameter pack is empty 
&&  true 
  false 
,  void() 
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>  <future>  <numeric>  <strstream> 
<any>  <initializer_list>  <optional>  <system_error> 
<array>  <iomanip>  <ostream>  <thread> 
<atomic>  <ios>  <queue>  <tuple> 
<bitset>  <iosfwd>  <random>  <type_traits> 
<chrono>  <iostream>  <ratio>  <typeindex> 
<codecvt>  <istream>  <regex>  <typeinfo> 
<complex>  <iterator>  <scoped_allocator>  <unordered_map> 
<condition_variable>  <limits>  <set>  <unordered_set> 
<deque>  <list>  <shared_mutex>  <utility> 
<exception>  <locale>  <sstream>  <valarray> 
<execution>  <map>  <stack>  <variant> 
<filesystem>  <memory>  <stdexcept>  <vector> 
<forward_list>  <memory_resource>  <streambuf>  
<fstream>  <mutex>  <string>  
<functional>  <new>  <string_view> 
<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> 
abort_handler_s  mbstowcs_s  strncat_s  vswscanf_s 
asctime_s  memcpy_s  strncpy_s  vwprintf_s 
bsearch_s  memmove_s  strtok_s  vwscanf_s 
constraint_handler_t  memset_s  swprintf_s  wcrtomb_s 
ctime_s  printf_s  swscanf_s  wcscat_s 
errno_t  qsort_s  tmpfile_s  wcscpy_s 
fopen_s  RSIZE_MAX  TMP_MAX_S  wcsncat_s 
fprintf_s  rsize_t  tmpnam_s  wcsncpy_s 
freopen_s  scanf_s  vfprintf_s  wcsnlen_s 
fscanf_s  set_constraint_handler_s  vfscanf_s  wcsrtombs_s 
fwprintf_s  snprintf_s  vfwprintf_s  wcstok_s 
fwscanf_s  snwprintf_s  vfwscanf_s  wcstombs_s 
getenv_s  sprintf_s  vprintf_s  wctomb_s 
gets_s  sscanf_s  vscanf_s  wmemcpy_s 
gmtime_s  strcat_s  vsnprintf_s  wmemmove_s 
ignore_handler_s  strcpy_s  vsnwprintf_s  wprintf_s 
L_tmpnam_s  strerror_s  vsprintf_s  wscanf_s 
localtime_s  strerrorlen_s  vsscanf_s  
mbsrtowcs_s  strlen_s  vswprintf_s 
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  <cstdarg> 
[meta]  Type traits  <type_traits> 
[atomics]  Atomics  <atomic> 
[depr.cstdalign.syn], [depr.cstdbool.syn]  Deprecated headers  <cstdalign> <cstdbool> 
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 
Expression  Postcondition 
T t;  object t is defaultinitialized 
T u{};  object u is valueinitialized or aggregateinitialized 
T() T{}  an object of type T is valueinitialized or aggregateinitialized 
Expression  Postcondition 
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  Postcondition 
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  Postcondition 
t = rv  T&  t  If t and rv do not refer to the same object, 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, whether or not t and rv refer to the same object. 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  Postcondition 
t = v  T&  t  t is equivalent to v, the value of v is unchanged 
Expression  Postcondition 
u.~T()  All resources owned by u are reclaimed, no exception is propagated. 
Expression  Return type  Operational semantics 
P u(np);  Postconditions: u == nullptr  
P u = np;  
P(np)  Postconditions: P(np) == nullptr  
t = np  P&  Postconditions: 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 cvunqualified object type ([basic.types]) 
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> 
a, a1, a2  lvalues of type X 
u  the name of a variable being declared 
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 
x  a value of type XX::const_void_pointer obtained by conversion from a value q or a value w 
y  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. 
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/postcondition  
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  Requires: (*p).m is welldefined. equivalent to (*p).m  
q>m  type of T::m  Requires: (*q).m is welldefined. equivalent to (*q).m  
static_cast<X::pointer>(w)  X::pointer  static_cast<X::pointer>(w) == p  
static_cast<X::const_pointer>(x)  X::const_pointer  static_cast< X::const_pointer>(x) == q  
pointer_traits<X::pointer>::pointer_to(r)  X::pointer  
a.allocate(n)  X::pointer  Memory is allocated for n objects of type T but objects are not constructed. allocate may throw an appropriate exception.175 [ Note: If n == 0, the return value is unspecified. — end note ]  
a.allocate(n, y)  X::pointer  Same as a.allocate(n). The use of y is unspecified, but it is intended as an aid to locality.  a.allocate(n) 
a.deallocate(p,n)  (not used) 
Requires: p shall be a value returned by an earlier call
to allocate that has not been invalidated by
an intervening call to deallocate. n shall
match the value passed to allocate to obtain this memory. Throws: Nothing.  
a.max_size()  X::size_type  the largest value that can meaningfully be passed to X::allocate()  numeric_limits<size_type>::max() / sizeof(value_type) 
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 u(a); X u = a; 
Shall not exit via an exception. Postconditions: u == a  
X u(b); 
Shall not exit via an exception. Postconditions: Y(u) == b, u == X(b)  
X u(std::move(a)); X u = std::move(a); 
Shall not exit via an exception. Postconditions: u is equal to the prior value of a.  
X u(std::move(b)); 
Shall not exit via an exception. Postconditions: u is equal to the prior value of X(b).  
a.construct(c, args)  (not used)  Effects: Constructs an object of type C at c  ::new ((void*)c) C(forward<Args>(args)...) 
a.destroy(c)  (not used)  Effects: 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 copyassigned. See Note B, below.  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 moveassigned. See Note B, below.  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. See Note B, below.  false_type 
X::is_always_equal  Identical to or derived from true_type or false_type  true_type only if the expression a1 == a2 is guaranteed to be true for any two (possibly const) values a1, a2 of type X.  is_empty<X>::type 
Subclause  Header(s)  
[support.types]  Common definitions  <cstddef> 
<cstdlib>  
[support.limits]  Implementation properties  <limits> 
<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> 
[support.runtime]  Other runtime support  <csignal> 
<csetjmp>  
<cstdarg>  
<cstdlib> 
Subclause  Header(s)  
[std.exceptions]  Exception classes  <stdexcept> 
[assertions]  Assertions  <cassert> 
[errno]  Error numbers  <cerrno> 
[syserr]  System error support  <system_error> 
Subclause  Header(s)  
[utility]  Utility components  <utility> 
[intseq]  Compiletime integer sequences  <utility> 
[pairs]  Pairs  <utility> 
[tuple]  Tuples  <tuple> 
[optional]  Optional objects  <optional> 
[variant]  Variants  <variant> 
[any]  Storage for any type  <any> 
[bitset]  Fixedsize sequences of bits  <bitset> 
[memory]  Memory  <memory> 
<cstdlib>  
[smartptr]  Smart pointers  <memory> 
[mem.res]  Memory resources  <memory_resource> 
[allocator.adaptor]  Scoped allocators  <scoped_allocator> 
[function.objects]  Function objects  <functional> 
[meta]  Type traits  <type_traits> 
[ratio]  Compiletime rational arithmetic  <ratio> 
[time]  Time utilities  <chrono> 
<ctime>  
[type.index]  Type indexes  <typeindex> 
[execpol]  Execution policies  <execution> 
*this contains a value  *this does not contain a value  
rhs contains a value  assigns *rhs to the contained value  initializes the contained value as if directnonlistinitializing an object of type T with *rhs 
rhs does not contain a value  destroys the contained value by calling val>T::~T()  no effect 
*this contains a value  *this does not contain a value  
rhs contains a value  assigns std::move(*rhs) to the contained value  initializes the contained value as if directnonlistinitializing an object of type T with std::move(*rhs) 
rhs does not contain a value  destroys the contained value by calling val>T::~T()  no effect 
*this contains a value  *this does not contain a value  
rhs contains a value  assigns *rhs to the contained value  initializes the contained value as if directnonlistinitializing an object of type T with *rhs 
rhs does not contain a value  destroys the contained value by calling val>T::~T()  no effect 
*this contains a value  *this does not contain a value  
rhs contains a value  assigns std::move(*rhs) to the contained value  initializes the contained value as if directnonlistinitializing an object of type T with std::move(*rhs) 
rhs does not contain a value  destroys the contained value by calling val>T::~T()  no effect 
*this contains a value  *this does not contain a value  
rhs contains a value  calls swap(*(*this), *rhs)  initializes the contained value of *this as if directnonlistinitializing an object of type T with the expression std::move(*rhs), followed by rhs.val>T::~T(); postcondition is that *this contains a value and rhs does not contain a value 
rhs does not contain a value  initializes the contained value of rhs as if directnonlistinitializing an object of type T with the expression std::move(*(*this)), followed by val>T::~T(); postcondition is that *this does not contain a value and rhs contains a value  no effect 
Template  Condition  Comments 
template <class T> struct is_void;  T is void  
template <class T> struct is_null_pointer;  T is nullptr_t ([basic.fundamental])  
template <class T> struct is_integral;  T is an integral type  
template <class T> struct is_floating_point;  T is a floatingpoint type  
template <class T> struct is_array;  T is an array type ([basic.compound]) of known or unknown extent  Class template array is not an array type. 
template <class T> struct is_pointer;  T is a pointer type  Includes pointers to functions but not pointers to nonstatic members. 
template <class T> struct is_lvalue_reference;  T is an lvalue reference type  
template <class T> struct is_rvalue_reference;  T is an rvalue reference type  
template <class T> struct is_member_object_pointer;  T is a pointer to nonstatic data member  
template <class T> struct is_member_function_pointer;  T is a pointer to nonstatic 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 nonunion class 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  
template <class T> struct is_fundamental;  T is a fundamental type  
template <class T> struct is_object;  T is an object type  
template <class T> struct is_scalar;  T is a scalar type  
template <class T> struct is_compound;  T is a compound type  
template <class T> struct is_member_pointer;  T is a pointer to nonstatic data member or nonstatic member function 
Template  Condition  Preconditions 
template <class T> struct is_const;  T is constqualified  
template <class T> struct is_volatile;  T is volatilequalified  
template <class T> struct is_trivial;  T is a trivial type  remove_all_extents_t<T> shall be a complete type or cv void. 
template <class T> struct is_trivially_copyable;  T is a trivially copyable type  remove_all_extents_t<T> shall be a complete type or cv void. 
template <class T> struct is_standard_layout;  T is a standardlayout type  remove_all_extents_t<T> shall be a complete type or cv void. 
template <class T> struct is_pod;  T is a POD type  remove_all_extents_t<T> shall be a complete type or cv void. 
template <class T> struct is_empty;  T is a class type, but not a union type, with no nonstatic data members other than bitfields of length 0, no virtual member functions, no virtual base classes, and no base class B for which is_empty_v<B> is false.  If T is a nonunion class type, T shall be a complete type. 
template <class T> struct is_polymorphic;  T is a polymorphic class  If T is a nonunion class type, T shall be a complete type. 
template <class T> struct is_abstract;  T is an abstract class  If T is a nonunion class type, T shall be a complete type. 
template <class T> struct is_final;  T is a class type marked with the classvirtspecifier 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_aggregate;  T is an aggregate type ([dcl.init.aggr])  remove_all_extents_t<T> shall be a complete type or cv void. 
template <class T> struct is_signed;  If is_arithmetic_v<T> is true, the same result as T(1) < T(0); otherwise, false  
template <class T> struct is_unsigned;  If is_arithmetic_v<T> is true, the same result as T(0) < T(1); otherwise, false  
template <class T, class... Args> struct is_constructible;  For a function type T or for a cv void type T, is_constructible_v<T, Args...> is false, otherwise see below  T and all types in the parameter pack Args shall be complete types, cv void, or arrays of unknown bound. 
template <class T> struct is_default_constructible;  is_constructible_v<T> is true.  T shall be a complete type, cv 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_v<T, const T&>, otherwise false.  T shall be a complete type, cv 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_v<T, T&&>, otherwise false.  T shall be a complete type, cv void, or an array of unknown bound. 
template <class T, class U> struct is_assignable;  The expression declval<T>() = declval<U>() is wellformed when treated as an unevaluated operand. 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 implicitlydefined functions, and so on. Such side effects are not in the “immediate context” and can result in the program being illformed. — end note ]  T and U shall be complete types, cv void, or arrays of unknown bound. 
template <class T> struct is_copy_assignable;  For a referenceable type T, the same result as is_assignable_v<T&, const T&>, otherwise false.  T shall be a complete type, cv 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_v<T&, T&&>, otherwise false.  T shall be a complete type, cv void, or an array of unknown bound. 
template <class T, class U> struct is_swappable_with;  The expressions swap(declval<T>(), declval<U>()) and swap(declval<U>(), declval<T>()) are each wellformed when treated as an unevaluated operand in an overloadresolution context for swappable values ([swappable.requirements]). Access checking is performed as if in a context unrelated to T and U. Only the validity of the immediate context of the swap expressions is considered. [ Note: The compilation of the expressions can result in side effects such as the instantiation of class template specializations and function template specializations, the generation of implicitlydefined functions, and so on. Such side effects are not in the “immediate context” and can result in the program being illformed. — end note ]  T and U shall be complete types, cv void, or arrays of unknown bound. 
template <class T> struct is_swappable;  For a referenceable type T, the same result as is_swappable_with_v<T&, T&>, otherwise false.  T shall be a complete type, cv void, or an array of unknown bound. 
template <class T> struct is_destructible;  Either T is a reference type, or T is a complete object type for which the expression declval<U&>().~U() is wellformed when treated as an unevaluated operand, where U is remove_all_extents<T>.  T shall be a complete type, cv void, or an array of unknown bound. 
template <class T, class... Args> struct is_trivially_constructible; 
is_constructible_v<T, Args...> 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, cv void, or arrays of unknown bound. 
template <class T> struct is_trivially_default_constructible;  is_trivially_constructible_v<T> is true.  T shall be a complete type, cv 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_v<T, const T&>, otherwise false.  T shall be a complete type, cv 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_v<T, T&&>, otherwise false.  T shall be a complete type, cv void, or an array of unknown bound. 
template <class T, class U> struct is_trivially_assignable;  is_assignable_v<T, U> 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, cv 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_v<T&, const T&>, otherwise false.  T shall be a complete type, cv 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_v<T&, T&&>, otherwise false.  T shall be a complete type, cv void, or an array of unknown bound. 
template <class T> struct is_trivially_destructible;  is_destructible_v<T> is true and the indicated destructor is known to be trivial.  T shall be a complete type, cv void, or an array of unknown bound. 
template <class T, class... Args> struct is_nothrow_constructible;  is_constructible_v<T, Args...> 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, cv void, or arrays of unknown bound. 
template <class T> struct is_nothrow_default_constructible;  is_nothrow_constructible_v<T> is true.  T shall be a complete type, cv 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_v<T, const T&>, otherwise false.  T shall be a complete type, cv 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_v<T, T&&>, otherwise false.  T shall be a complete type, cv void, or an array of unknown bound. 
template <class T, class U> struct is_nothrow_assignable;  is_assignable_v<T, U> is true and the assignment is known not to throw any exceptions ([expr.unary.noexcept]).  T and U shall be complete types, cv 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_v<T&, const T&>, otherwise false.  T shall be a complete type, cv 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_v<T&, T&&>, otherwise false.  T shall be a complete type, cv void, or an array of unknown bound. 
template <class T, class U> struct is_nothrow_swappable_with;  is_swappable_with_v<T, U> is true and each swap expression of the definition of is_swappable_with<T, U> is known not to throw any exceptions ([expr.unary.noexcept]).  T and U shall be complete types, cv void, or arrays of unknown bound. 
template <class T> struct is_nothrow_swappable;  For a referenceable type T, the same result as is_nothrow_swappable_with_v<T&, T&>, otherwise false.  T shall be a complete type, cv void, or an array of unknown bound. 
template <class T> struct is_nothrow_destructible;  is_destructible_v<T> is true and the indicated destructor is known not to throw any exceptions ([expr.unary.noexcept]).  T shall be a complete type, cv void, or an array of unknown bound. 
template <class T> struct has_virtual_destructor;  T has a virtual destructor  If T is a nonunion class type, T shall be a complete type. 
template <class T> struct has_unique_object_representations;  For an array type T, the same result as has_unique_object_representations_v<remove_all_extents_t<T>>, otherwise see below.  T shall be a complete type, cv void, or an array of unknown bound. 
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 zerobased 
Template  Condition  Comments 
template <class T, class U> struct is_same;  T and U name the same type with the same cvqualifications  
template <class Base, class Derived> struct is_base_of;  Base is a base class of Derived (Clause [class.derived]) without regard to cvqualifiers or Base and Derived are not unions and name the same class type without regard to cvqualifiers  If Base and Derived are nonunion class types and are not possibly cvqualified versions of the same type, 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 cv void types. 
template <class Fn, class... ArgTypes> struct is_invocable;  The expression INVOKE(declval<Fn>(), declval<ArgTypes>()...) is well formed when treated as an unevaluated operand  Fn and all types in the parameter pack ArgTypes shall be complete types, cv void, or arrays of unknown bound. 
template <class R, class Fn, class... ArgTypes> struct is_invocable_r;  The expression INVOKE<R>(declval<Fn>(), declval<ArgTypes>()...) is well formed when treated as an unevaluated operand  Fn, R, and all types in the parameter pack ArgTypes shall be complete types, cv void, or arrays of unknown bound. 
template <class Fn, class... ArgTypes> struct is_nothrow_invocable; 
is_invocable_v< Fn, ArgTypes...> is true and the expression INVOKE(declval<Fn>(), declval<ArgTypes>()...) is known not to throw any exceptions  Fn and all types in the parameter pack ArgTypes shall be complete types, cv void, or arrays of unknown bound. 
template <class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r; 
is_invocable_r_v< R, Fn, ArgTypes...> is true and the expression INVOKE<R>(declval<Fn>(), declval<ArgTypes>()...) is known not to throw any exceptions  Fn, R, and all types in the parameter pack ArgTypes shall be complete types, cv void, or arrays of unknown bound. 
Template  Comments 
template <class T> struct remove_reference;  If T has type “reference to T1” then the member typedef type names T1; otherwise, type names T. 
template <class T> struct add_lvalue_reference;  If T names a referenceable type then the member typedef type names T&; otherwise, type names T. [ Note: This rule reflects the semantics of reference collapsing ([dcl.ref]). — end note ] 
template <class T> struct add_rvalue_reference;  If T names a referenceable type then the member typedef type names T&&; otherwise, type names 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 cvqualified)
signed integer type then the member typedef
type names the type T; otherwise,
if T names a (possibly cvqualified) unsigned integer
type then type names the corresponding
signed integer type, with the same cvqualifiers as T;
otherwise, type names the signed integer type with smallest
rank for which
sizeof(T) == sizeof(type), with the same
cvqualifiers as T. Requires: T shall be a (possibly cvqualified) integral type or enumeration but not a bool type. 
template <class T> struct make_unsigned; 
If T names a (possibly cvqualified)
unsigned integer type then the member typedef
type names the type T; otherwise,
if T names a (possibly cvqualified) signed integer
type then type names the corresponding
unsigned integer type, with the same cvqualifiers as T;
otherwise, type names the unsigned integer type with smallest
rank for which
sizeof(T) == sizeof(type), with the same
cvqualifiers as T. Requires: T shall be a (possibly cvqualified) integral type or enumeration but not a bool type. 
Template  Comments 
template <class T> struct remove_pointer;  If T has type “(possibly cvqualified) pointer to T1” then the member typedef type names T1; otherwise, it names T. 
template <class T> struct add_pointer;  If T names a referenceable type or a cv void type then the member typedef type names the same type as remove_reference_t<T>*; otherwise, type names T. 
Template  Comments 
template <size_t Len, size_t Align = defaultalignment> struct aligned_storage; 
The value of defaultalignment 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. Requires: Len shall not be zero. Align shall be equal to alignof(T) for some type T or to defaultalignment. 
template <size_t Len, class... Types> struct aligned_union; 
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 size_t whose value is the
strictest alignment of all types listed in Types. Requires: At least one type is provided. 
template <class T> struct decay;  Let U be remove_reference_t<T>. If is_array_v<U> is true, the member typedef type shall equal remove_extent_t<U>*. If is_function_v<U> 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 lvaluetorvalue, arraytopointer, and functiontopointer conversions applied when an lvalue expression is used as an rvalue, but also strips cvqualifiers from class types in order to more closely model byvalue 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;  Unless this trait is specialized (as specified in Note B, below), the member type shall be defined or omitted as specified in Note A, below. If it is omitted, there shall be no member type. Each type in the parameter pack T shall be complete, cv void, or an array of unknown bound. 
template <class T> struct underlying_type; 
The member typedef type names the underlying type
of T. Requires: T shall be a complete enumeration type 
template <class Fn, class... ArgTypes> struct invoke_result; 
If the expression INVOKE(declval<Fn>(), declval<ArgTypes>()...)
is well formed when treated as an unevaluated operand,
the member typedef type names 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 implicitlydefined
functions, and so on. Such side effects are not in the “immediate
context” and can result in the program being illformed.
— end note ] Requires: Fn and all types in the parameter pack ArgTypes shall be complete types, cv void, or arrays of unknown bound. 
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. 
Subclause  Header(s)  
[char.traits]  Character traits  <string> 
[string.classes]  String classes  <string> 
[string.view]  String view classes  <string_view> 
<cctype>  
<cwctype>  
[c.strings]  Nullterminated sequence utilities  <cstring> 
<cwchar>  
<cstdlib>  
<cuchar> 
Expression  Return type  Assertion/note  Complexity 
pre/postcondition  
X::char_type  charT  (described in [char.traits.typedefs])  compiletime 
X::int_type  (described in [char.traits.typedefs])  compiletime  
X::off_type  (described in [char.traits.typedefs])  compiletime  
X::pos_type  (described in [char.traits.typedefs])  compiletime  
X::state_type  (described in [char.traits.typedefs])  compiletime  
X::eq(c,d)  bool  Returns: whether c is to be treated as equal to d.  constant 
X::lt(c,d)  bool  Returns: whether c is to be treated as less than d.  constant 
X::compare(p,q,n)  int  Returns: 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)  size_t  Returns: the smallest i such that X::eq(p[i],charT()) is true.  linear 
X::find(p,n,c)  const X::char_type*  Returns: 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. Returns: s.  linear 
X::copy(s,p,n)  X::char_type* 
Requires: p not in [s,s+n). Returns: 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). Returns: s.  linear 
X::not_eof(e)  int_type  Returns: 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  Returns: 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  Returns: some value e, constrained by the definitions of to_char_type and eq_int_type.  constant 
X::eq_int_type(e,f)  bool  Returns: 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  Returns: 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 nonnull 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() 
Condition  Return Value 
size() < sv.size()  < 0 
size() == sv.size()  0 
size() > sv.size()  > 0 
Element  Value 
data_  str 
size_  traits::length(str) 
Condition  Return Value 
size() < str.size()  < 0 
size() == str.size()  0 
size() > str.size()  > 0 
Expression  Equivalent to 
t == sv  S(t) == sv 
sv == t  sv == S(t) 
t != sv  S(t) != sv 
sv != t  sv != S(t) 
t < sv  S(t) < sv 
sv < t  sv < S(t) 
t > sv  S(t) > sv 
sv > t  sv > S(t) 
t <= sv  S(t) <= sv 
sv <= t  sv <= S(t) 
t >= sv  S(t) >= sv 
sv >= t  sv >= S(t) 
Subclause  Header(s)  
[locales]  Locales  <locale> 
[locale.categories]  Standard locale Categories  
[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  showpos  + 
showbase  #  
a floatingpoint type  showpos  + 
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" 
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/postcondition  
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 nonnegative value of difference_type  compile time  
X u;  Postconditions: u.empty()  constant  
X()  Postconditions: X().empty()  constant  
X(a) 
Requires: T is CopyInsertable
into X (see below). Postconditions: a == X(a).  linear  
X u(a); X u = a; 
Requires: T is CopyInsertable
into X (see below). Postconditions: u == a  linear  
X u(rv); X u = rv;  Postconditions: 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  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&  Postconditions: 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/postcondition  
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/postcondition  
a < b  convertible to bool  lexicographical_compare( a.begin(), a.end(), b.begin(), b.end())  Requires: < 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/postcondition  
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. Postconditions: u.empty() returns true, u.get_allocator() == A()  constant  
X(m)  Postconditions: 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. Postconditions: u == t, u.get_allocator() == m  linear  
X(rv) X u(rv);  Postconditions: 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. Postconditions: 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. Postconditions: 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. Postconditions: 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/postcondition  
X(n, t) X u(n, t); 
Requires: T shall be
CopyInsertable into X. Postconditions: distance(begin(), end()) == n Constructs a sequence container with n copies of t  
X(i, j) X u(i, j); 
Requires: T shall be EmplaceConstructible into X from *i.
For vector, if the iterator does
not meet the forward iterator requirements, T
shall also be
MoveInsertable into X.
Each iterator in the range [i, j) shall be dereferenced exactly once. Postconditions: 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 and deque, T shall also be
MoveInsertable into X, MoveConstructible, MoveAssignable,
and swappable.
Each iterator in the range [i, j) shall be dereferenced exactly once. Requires: 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 pasttheend iterator. Postconditions: 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, T
shall also be
MoveInsertable into X. Each iterator in the range [i, j) shall be dereferenced exactly once. Requires: i, j are not iterators into a. Replaces elements in a with a copy of [i, j). Invalidates all references, pointers and iterators referring to the elements of a. For vector and deque, also invalidates the pasttheend iterator. 
a.assign(il)  void  a.assign(il.begin(), il.end()). 
a.assign(n,t)  void 
Requires: T shall be
CopyInsertable into X
and CopyAssignable. Requires: t is not a reference into a. Replaces elements in a with n copies of t. Invalidates all references, pointers and iterators referring to the elements of a. For vector and deque, also invalidates the pasttheend iterator. 
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)  reference 
Prepends an object of type T constructed with std::forward<Args>(args).... Requires: T shall be EmplaceConstructible into X from args. Returns: a.front().  deque, forward_list, list 
a.emplace_back(args)  reference 
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. Returns: a.back().  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 
map<K, T, C1, A>  map<K, T, C2, A> 
map<K, T, C1, A>  multimap<K, T, C2, A> 
set<K, C1, A>  set<K, C2, A> 
set<K, C1, A>  multiset<K, C2, A> 
unordered_map<K, T, H1, E1, A>  unordered_map<K, T, H2, E2, A> 
unordered_map<K, T, H1, E1, A>  unordered_multimap<K, T, H2, E2, A> 
unordered_set<K, H1, E1, A>  unordered_set<K, H2, E2, A> 
unordered_set<K, H1, E1, A>  unordered_multiset<K, H2, E2, A> 
Expression  Return type  Assertion/note  Complexity 
pre/postcondition  
X::key_type  Key  compile time  
X::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  Requires: key_compare is CopyConstructible.  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::node_type  a specialization of a node_handle class template, such that the public nested types are the same types as the corresponding types in X.  see [container.node]  compile time 
X(c) X u(c);  Effects: Constructs an empty container. Uses a copy of c as a comparison object.  constant  
X() X u; 
Requires: key_compare is DefaultConstructible. Effects: Constructs an empty container. Uses Compare() as a comparison object  constant  
X(i,j,c) X u(i,j,c); 
Requires: 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.  in general, where N has the value distance(i, j); linear if [i, j) is sorted with value_comp()  
X(i,j) X u(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.  in general, where N has the value il.size() + a.size(); linear if [il.begin(), il.end()) is sorted with value_comp() 
b.key_comp()  X::key_compare  returns the comparison object out of which b was constructed.  constant 
b.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 nonconst 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 nonconst 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 nonconst 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. Requires: 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.  , where N has the value distance(i, j) 
a.insert(il)  void  equivalent to a.insert(il.begin(), il.end())  
a_uniq.insert(nh)  insert_return_type 
Requires: nh is empty or
a_uniq.get_allocator() == nh.get_allocator(). Effects: If nh is empty, has no effect. Otherwise, inserts the element owned by nh if and only if there is no element in the container with a key equivalent to nh.key(). Postconditions: If nh is empty, inserted is false, position is end(), and node is empty. Otherwise if the insertion took place, inserted is true, position points to the inserted element, and node is empty; if the insertion failed, inserted is false, node has the previous value of nh, and position points to an element with a key equivalent to nh.key().  logarithmic 
a_eq.insert(nh)  iterator 
Requires: nh is empty or
a_eq.get_allocator() == nh.get_allocator(). Effects: If nh is empty, has no effect and returns a_eq.end(). Otherwise, inserts the element owned by nh and returns an iterator pointing to the newly inserted element. If a range containing elements with keys equivalent to nh.key() exists in a_eq, the element is inserted at the end of that range. Postconditions: nh is empty.  logarithmic 
a.insert(p, nh)  iterator 
Requires: nh is empty or
a.get_allocator() == nh.get_allocator(). Effects: If nh is empty, has no effect and returns a.end(). Otherwise, inserts the element owned by nh if and only if there is no element with key equivalent to nh.key() in containers with unique keys; always inserts the element owned by nh in containers with equivalent keys. Always returns the iterator pointing to the element with key equivalent to nh.key(). The element is inserted as close as possible to the position just prior to p. Postconditions: nh is empty if insertion succeeds, unchanged if insertion fails.  logarithmic in general, but amortized constant if the element is inserted right before p. 
a.extract(k)  node_type  removes the first element in the container with key equivalent to k. Returns a node_type owning the element if found, otherwise an empty node_type.  log(a.size()) 
a.extract(q)  node_type  removes the element pointed to by q. Returns a node_type owning that element.  amortized constant 
a.merge(a2)  void 
Requires: a.get_allocator() == a2.get_allocator(). Attempts to extract each element in a2 and insert it into a using the comparison object of a. In containers with unique keys, if there is an element in a with key equivalent to the key of an element from a2, then that element is not extracted from a2. Postconditions: Pointers and references to the transferred elements of a2 refer to those same elements but as members of a. Iterators referring to the transferred elements will continue to refer to their elements, but they now behave as iterators into a, not into a2. Throws: Nothing unless the comparison object throws.  , where N has the value a2.size(). 
a.erase(k)  size_type  erases all elements in the container with key equivalent to k. returns the number of erased elements.  
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(r)  iterator  erases the element pointed to by r. Returns an iterator pointing to the element immediately following r 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.  , where N has the value distance(q1, q2). 
a.clear()  void 
a.erase(a.begin(),a.end()) Postconditions: a.empty() returns true.  linear in a.size(). 
b.find(k)  iterator; const_iterator for constant b.  returns an iterator pointing to an element with the key equivalent to k, or b.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 
b.count(k)  size_type  returns the number of elements with key equivalent to k  
a_tran. count(ke)  size_type  returns the number of elements with key r such that !c(r, ke) && !c(ke, r)  
b.lower_bound(k)  iterator; const_iterator for constant b.  returns an iterator pointing to the first element with key not less than k, or b.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 
b.upper_bound(k)  iterator; const_iterator for constant b.  returns an iterator pointing to the first element with key greater than k, or b.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 
b.equal_range(k)  pair<iterator, iterator>; pair<const_iterator, const_iterator> for constant b.  equivalent to make_pair(b.lower_bound(k), b.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  Complexity 
pre/postcondition  
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 size_t.  compile time 
X::key_equal  Pred  Requires: Pred is CopyConstructible. 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::node_type  a specialization of a node_handle class template, such that the public nested types are the same types as the corresponding types in X.  see [container.node]  compile time 
X(n, hf, eq) X a(n, hf, eq);  X  Effects: Constructs an empty container with at least n buckets, using hf as the hash function and eq as the key equality predicate.  
X(n, hf) X a(n, hf);  X  Requires: 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.  
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.  
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: 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 is distance(i, j)), worst case 
X(i, j, n, hf) X a(i, j, n, hf);  X  Requires: 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 is distance(i, j)), worst case 
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 is distance(i, j)), worst case 
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 is distance(i, j)), worst case 
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 83, 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 83, 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 , worst case . 
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 , worst case . 
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 , worst case . 
a_uniq.insert(t)  pair<iterator, bool>  Requires: If t is a nonconst 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 , worst case . 
a_eq.insert(t)  iterator  Requires: If t is a nonconst 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 , worst case . 
a.insert(p, t)  iterator  Requires: If t is a nonconst 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 p is a hint pointing to where the search should start. Implementations are permitted to ignore the hint.  Average case , worst case . 
a.insert(i, j)  void  Requires: value_type shall be EmplaceConstructible into X from *i. Requires: i and j are not iterators in a. Equivalent to a.insert(t) for each element in [i,j).  Average case , where N is distance(i, j). Worst case . 
a.insert(il)  void  Same as a.insert(il.begin(), il.end()).  Same as a.insert( il.begin(), il.end()). 
a_uniq. insert(nh)  insert_return_type 
Requires: nh is empty or
a_uniq.get_allocator() == nh.get_allocator(). Effects: If nh is empty, has no effect. Otherwise, inserts the element owned by nh if and only if there is no element in the container with a key equivalent to nh.key(). Postconditions: If nh is empty, inserted is false, position is end(), and node is empty. Otherwise if the insertion took place, inserted is true, position points to the inserted element, and node is empty; if the insertion failed, inserted is false, node has the previous value of nh, and position points to an element with a key equivalent to nh.key().  Average case , worst case . 
a_eq. insert(nh)  iterator 
Requires: nh is empty or
a_eq.get_allocator() == nh.get_allocator(). Effects: If nh is empty, has no effect and returns a_eq.end(). Otherwise, inserts the element owned by nh and returns an iterator pointing to the newly inserted element. Postconditions: nh is empty.  Average case , worst case . 
a.insert(q, nh)  iterator 
Requires: nh is empty or
a.get_allocator() == nh.get_allocator(). Effects: If nh is empty, has no effect and returns a.end(). Otherwise, inserts the element owned by nh if and only if there is no element with key equivalent to nh.key() in containers with unique keys; always inserts the element owned by nh in containers with equivalent keys. Always returns the iterator pointing to the element with key equivalent to nh.key(). The iterator q is a hint pointing to where the search should start. Implementations are permitted to ignore the hint. Postconditions: nh is empty if insertion succeeds, unchanged if insertion fails.  Average case , worst case . 
a.extract(k)  node_type  Removes an element in the container with key equivalent to k. Returns a node_type owning the element if found, otherwise an empty node_type.  Average case , worst case . 
a.extract(q)  node_type  Removes the element pointed to by q. Returns a node_type owning that element.  Average case , worst case . 
a.merge(a2)  void 
Requires: a.get_allocator() == a2.get_allocator(). Attempts to extract each element in a2 and insert it into a using the hash function and key equality predicate of a. In containers with unique keys, if there is an element in a with key equivalent to the key of an element from a2, then that element is not extracted from a2. Postconditions: Pointers and references to the transferred elements of a2 refer to those same elements but as members of a. Iterators referring to the transferred elements and all iterators referring to a will be invalidated, but iterators to elements remaining in a2 will remain valid. Throws: Nothing unless the hash function or key equality predicate throws.  Average case , where N is a2.size(). Worst case . 
a.erase(k)  size_type  Erases all elements with key equivalent to k. Returns the number of elements erased.  Average case . Worst case . 
a.erase(q)  iterator  Erases the element pointed to by q. Returns the iterator immediately following q prior to the erasure.  Average case , worst case . 
a.erase(r)  iterator  Erases the element pointed to by r. Returns the iterator immediately following r prior to the erasure.  Average case , worst case . 
a.erase(q1, q2)  iterator  Erases all elements in the range [q1, q2). Returns the iterator immediately following the erased elements prior to the erasure.  Average case linear in distance(q1, q2), worst case . 
a.clear()  void  Erases all elements in the container. Postconditions: a.empty() returns true  Linear in a.size(). 
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 , worst case . 
b.count(k)  size_type  Returns the number of elements with key equivalent to k.  Average case , worst case . 
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 . Worst case . 
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 
Requires: 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. Postconditions: the return value shall be in the range [0, b.bucket_count()).  Constant 
b.bucket_size(n)  size_type  Requires: n shall be in the range [0, b.bucket_count()). Returns the number of elements in the bucket.  
b.begin(n)  local_iterator; const_local_iterator for const b.  Requires: 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.  Requires: n shall be in the range [0, b.bucket_count()). b.end(n) returns an iterator which is the pasttheend value for the bucket.  Constant 
b.cbegin(n)  const_local_iterator  Requires: 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 bucket.  Constant 
b.cend(n)  const_local_iterator  Requires: 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  Requires: z shall be positive. May change the container's maximum load factor, using z as a hint.  Constant 
a.rehash(n)  void  Postconditions: 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/postcondition  
*r  unspecified  Requires: r is dereferenceable.  
++r  X& 
Expression  Return type  Operational  Assertion/note 
semantics  pre/postcondition  
a != b  contextually convertible to bool  !(a == b)  Requires: (a, b) is in the domain of ==. 
*a  reference, convertible to T 
Requires: 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  Requires: a is dereferenceable.  
++r  X& 
Requires: r is dereferenceable. Postconditions: r is dereferenceable or r is pasttheend; 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/postcondition  
*r = o  result is not used 
Remarks: After this operation r is not required to be dereferenceable. Postconditions: r is incrementable.  
++r  X& 
&r == &++r. Remarks: After this operation r is not required to be dereferenceable. Postconditions: r is incrementable.  
r++  convertible to const X& 
{ X tmp = r; ++r; return tmp; } 
Remarks: After this operation r is not required to be dereferenceable. Postconditions: r is incrementable. 
*r++ = o  result is not used 
Remarks: After this operation r is not required to be dereferenceable. Postconditions: r is incrementable. 
Expression  Return type  Operational  Assertion/note 
semantics  pre/postcondition  
r++  convertible to const X& 
{ X tmp = r; ++r; return tmp; }  
*r++  reference 
Expression  Return type  Operational  Assertion/note 
semantics  pre/postcondition  
r  X& 
Requires: there exists s such that r == ++s. Postconditions: 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/postcondition  
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;  Requires: the absolute value of n is in the range of representable values of difference_type. 
a  n  X 
{ X tmp = a; return tmp = n; }  
b  a  difference_type  return n 
Requires: 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]  Nonmodifying 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)  
[numerics.defns]  Definitions  
[numeric.requirements]  Requirements  
[cfenv]  Floatingpoint environment  <cfenv> 
[complex.numbers]  Complex numbers  <complex> 
[rand]  Random number generation  <random> 
[numarray]  Numeric arrays  <valarray> 
[numeric.ops]  Generalized numeric operations  <numeric> 
[c.math]  Mathematical functions for  <cmath> 
floatingpoint types  <cstdlib> 
Expression  Return type  Pre/postcondition  Complexity 
S::result_type  T  T is an unsigned integer type of at least 32 bits.  compiletime 
S()  Creates a seed sequence with the same initial state as all other defaultconstructed 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 .  
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 with 32bit quantities that depend on the sequence supplied to the constructor and possibly also depend on the history of generate's previous invocations.  
r.size()  size_t  The number of 32bit units that would be copied by a call to r.param.  constant 
r.param(ob)  void  Copies to the given destination a sequence of 32bit 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. 
Expression  Return type  Pre/postcondition  Complexity 
G::result_type  T  T is an unsigned integer type.  compiletime 
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().  compiletime 
G::max()  T  Denotes the greatest value potentially returned by operator().  compiletime 
Expression  Return type  Pre/postcondition  Complexity 
E()  Creates an engine with the same initial state as all other defaultconstructed engines of type E.  
E(x)  Creates an engine that compares equal to x.  
E(s)  Creates an engine with initial state determined by s.  
E(q)268  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  Postconditions: e == E().  same as E() 
e.seed(s)  void  Postconditions: e == E(s).  same as E(s) 
e.seed(q)  void  Postconditions: e == E(q).  same as E(q) 
e()  T  Advances e's state e to e e) and returns GA(e).  per Table 103 
e.discard(z) 269  void  Advances e's state e to 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 and as the infinite sequences of values that would be generated by repeated future calls to x() and y(), respectively, returns true if ; else returns false.  
x != y  bool  !(x == y).  
os << x  reference to the type of os  With os.fmtflags set to ios_base::decios_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. Postconditions: The os.fmtflags and fill character are unchanged.  
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. Requires: 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. Postconditions: The is.fmtflags are unchanged. 
Expression  Return type  Pre/postcondition  Complexity 
D::result_type  T  T is an arithmetic type.  compiletime 
D::param_type  P  compiletime  
D()  Creates a distribution whose behavior is indistinguishable from that of any other newly defaultconstructed 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  Postconditions: d.param() == p.  no worse than the complexity of D(p) 
d(g)  T  With , the sequence of numbers returned by successive invocations with the same object g is randomly distributed according to the associated p(z {p}) or 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 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 , where and 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. Postconditions: 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])). Requires: 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. Postconditions: The is.fmtflags are unchanged. 
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> 
[filesystems]  File systems  <filesystem> 
[c.files]  C library files  <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 floatingpoint output in fixedpoint 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 floatingpoint output in scientific notation 
showbase  generates a prefix indicating the numeric base of generated integer output 
showpoint  generates a decimalpoint character unconditionally in generated floatingpoint output 
showpos  generates a + sign in nonnegative 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/postcondition  
P(i) 
p == P(i) note: a destructor is assumed.  
P p(i); P p = i;  Postconditions: 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 
Expression  Value 
runtime_error::what()  what_arg.c_str() 
code()  ec 
path1().empty()  true 
path2().empty()  true 
Expression  Value 
runtime_error::what()  what_arg.c_str() 
code()  ec 
path1()  Reference to stored copy of p1 
path2().empty()  true 
Expression  Value 
runtime_error::what()  what_arg.c_str() 
code()  ec 
path1()  Reference to stored copy of p1 
path2()  Reference to stored copy of p2 
Option group controlling copy_file function effects for existing target files  
Constant  Meaning 
none  (Default) Error; file already exists. 
skip_existing  Do not overwrite existing file, do not report an error. 
overwrite_existing  Overwrite the existing file. 
update_existing  Overwrite the existing file if it is older than the replacement file. 
Option group controlling copy function effects for subdirectories  
Constant  Meaning 
none  (Default) Do not copy subdirectories. 
recursive  Recursively copy subdirectories and their contents. 
Option group controlling copy function effects for symbolic links  
Constant  Meaning 
none  (Default) Follow symbolic links. 
copy_symlinks  Copy symbolic links as symbolic links rather than copying the files that they point to. 
skip_symlinks  Ignore symbolic links. 
Option group controlling copy function effects for choosing the form of copying  
Constant  Meaning 
none  (Default) Copy content. 
directories_only  Copy directory structure only, do not copy nondirectory files. 
create_symlinks  Make symbolic links instead of copies of files. The source path shall be an absolute path unless the destination path is in the current directory. 
create_hard_links  Make hard links instead of copies of files. 
Name  Value  POSIX  Definition or notes 
(octal)  macro  
none  0  There are no permissions set for the file.  
owner_read  0400  S_IRUSR  Read permission, owner 
owner_write  0200  S_IWUSR  Write permission, owner 
owner_exec  0100  S_IXUSR  Execute/search permission, owner 
owner_all  0700  S_IRWXU 
Read, write, execute/search by owner; owner_read  owner_write  owner_exec 
group_read  040  S_IRGRP  Read permission, group 
group_write  020  S_IWGRP  Write permission, group 
group_exec  010  S_IXGRP  Execute/search permission, group 
group_all  070  S_IRWXG 
Read, write, execute/search by group; group_read  group_write  group_exec 
others_read  04  S_IROTH  Read permission, others 
others_write  02  S_IWOTH  Write permission, others 
others_exec  01  S_IXOTH  Execute/search permission, others 
others_all  07  S_IRWXO 
Read, write, execute/search by others; others_read  others_write  others_exec 
all  0777  owner_all  group_all  others_all  
set_uid  04000  S_ISUID  SetuserID on execution 
set_gid  02000  S_ISGID  SetgroupID on execution 
sticky_bit  01000  S_ISVTX  Operating system dependent. 
mask  07777  all  set_uid  set_gid  sticky_bit  
unknown  0xFFFF  The permissions are not known, such as when a file_status object is created without specifying the permissions 
Name  Meaning 
replace  permissions shall replace the file's permission bits with perm 
add  permissions shall replace the file's permission bits with the bitwise OR of perm and the file's current permission bits. 
remove  permissions shall replace the file's permission bits with the bitwise AND of the complement of perm and the file's current permission bits. 
nofollow  permissions shall change the permissions of a symbolic link itself rather than the permissions of the file the link resolves to. 
Name  Meaning 
none  (Default) Skip directory symlinks, permission denied is an error. 
follow_directory_symlink  Follow rather than skip directory symlinks. 
skip_permission_denied  Skip directories that would otherwise result in permission denied. 
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/postcondition 
X::char_type  charT  The character container type used in the implementation of class template basic_regex. 
X::string_type  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.  A bitmask type representing a particular character classification. 
X::length(p)  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 subexpressions shall be considered to be marked, so that when a regular expression is matched against a character container sequence, no subexpression 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 "[ab]" shall be locale sensitive. 
ECMAScript  Specifies that the grammar recognized by the regular expression engine shall be that used by ECMAScript in ECMA262, 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. 
multiline  Specifies that ^ shall match the beginning of a line and $ shall match the end of a line, if the ECMAScript engine is selected. 
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
subsequence [first, first).

match_not_eow 
The expression "\\b" shall not match the
subsequence [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 subsequence 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 and iterators.

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 ECMA262, part 15.5.4.11 String.prototype.replace. In addition, during search and replace operations all nonoverlapping 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
[ba] 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 preset 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 subexpression n. Alternatively, if subexpression 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 subexpression n. Alternatively, if subexpression n did not participate in the match, then last. 
m[n].matched  For all integers 0 < n < m.size(), true if subexpression 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 subexpression n. Alternatively, if subexpression 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 subexpression n. Alternatively, if subexpression n did not participate in the match, then last . 
m[n].matched  For all integers 0 < n < m.size(), true if subexpression n participated in the match, false otherwise. 
Subclause  Header(s)  
[atomics.order]  Order and Consistency  
[atomics.lockfree]  Lockfree Property  
[atomics.types.generic]  Atomic Types  <atomic> 
[atomics.types.operations]  Operations on Atomic Types  
[atomics.flag]  Flag Type and Operations  
[atomics.fences]  Fences 
key  Op  Computation  key  Op  Computation 
add  +  addition  sub    subtraction 
or    bitwise inclusive or  xor  ^  bitwise exclusive or 
and  &  bitwise and 
Key  Op  Computation  Key  Op  Computation 
add  +  addition  sub    subtraction 
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.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). 