18 Language support library [language.support]

Minimum finite value.197

For floating types with denormalization, returns the minimum positive normalized value.

Meaningful for all specializations in which is_bounded != false, or is_bounded == false && is_signed == false.

Maximum finite value.198

Meaningful for all specializations in which is_bounded != false.

A finite value x such that there is no other finite value y where y < x.199

Meaningful for all specializations in which is_bounded != false.

Number of radix digits that can be represented without change.

For integer types, the number of non-sign bits in the representation.

For floating point types, the number of radix digits in the mantissa.200

Number of base 10 digits that can be represented without change.201

Meaningful for all specializations in which is_bounded != false.

Number of base 10 digits required to ensure that values which differ are always differentiated.

Meaningful for all floating point types.

True if the type is signed.

Meaningful for all specializations.

True if the type is integer.

Meaningful for all specializations.

True if the type uses an exact representation. All integer types are exact, but not all exact types are integer. For example, rational and fixed-exponent representations are exact but not integer.

Meaningful for all specializations.

For floating types, specifies the base or radix of the exponent representation (often 2).202

For integer types, specifies the base of the representation.203

Meaningful for all specializations.

Machine epsilon: the difference between 1 and the least value greater than 1 that is representable.204

Meaningful for all floating point types.

Measure of the maximum rounding error.205

Minimum negative integer such that radix raised to the power of one less than that integer is a normalized floating point number.206

Meaningful for all floating point types.

Minimum negative integer such that 10 raised to that power is in the range of normalized floating point numbers.207

Meaningful for all floating point types.

Maximum positive integer such that radix raised to the power one less than that integer is a representable finite floating point number.208

Meaningful for all floating point types.

Maximum positive integer such that 10 raised to that power is in the range of representable finite floating point numbers.209

Meaningful for all floating point types.

True if the type has a representation for positive infinity.

Meaningful for all floating point types.

Shall be true for all specializations in which is_iec559 != false.

True if the type has a representation for a quiet (non-signaling) “Not a Number.”210

Meaningful for all floating point types.

Shall be true for all specializations in which is_iec559 != false.

True if the type has a representation for a signaling “Not a Number.”211

Meaningful for all floating point types.

Shall be true for all specializations in which is_iec559 != false.

denorm_present if the type allows denormalized values (variable number of exponent bits)212, denorm_absent if the type does not allow denormalized values, and denorm_indeterminate if it is indeterminate at compile time whether the type allows denormalized values.

Meaningful for all floating point types.

True if loss of accuracy is detected as a denormalization loss, rather than as an inexact result.213

Representation of positive infinity, if available.214

Meaningful for all specializations for which has_infinity != false. Required in specializations for which is_iec559 != false.

Representation of a quiet “Not a Number,” if available.215

Meaningful for all specializations for which has_quiet_NaN != false. Required in specializations for which is_iec559 != false.

Representation of a signaling “Not a Number,” if available.216

Meaningful for all specializations for which has_signaling_NaN != false. Required in specializations for which is_iec559 != false.

Minimum positive denormalized value.217

Meaningful for all floating point types.

In specializations for which has_denorm == false, returns the minimum positive normalized value.

True if and only if the type adheres to IEC 559 standard.218

Meaningful for all floating point types.

True if the set of values representable by the type is finite.219 [ Note: All fundamental types ([basic.fundamental]) are bounded. This member would be false for arbitrary precision types. — end note ]

Meaningful for all specializations.

True if the type is modulo.220 A type is modulo if, for any operation involving +, -, or * on values of that type whose result would fall outside the range [min(),max()], the value returned differs from the true value by an integer multiple of max() - min() + 1.

On most machines, this is false for floating types, true for unsigned integers, and true for signed integers.

Meaningful for all specializations.

true if, at program startup, there exists a value of the type that would cause an arithmetic operation using that value to trap.221

Meaningful for all specializations.

true if tinyness is detected before rounding.222

Meaningful for all floating point types.

The rounding style for the type.223

Meaningful for all floating point types. Specializations for integer types shall return round_toward_zero.

Effects: The allocation function ([basic.stc.dynamic.allocation]) called by a new-expression ([expr.new]) to allocate size bytes of storage suitably aligned to represent any object of that size.

Replaceable: a C++ program may define a function with this function signature that displaces the default version defined by the C++ standard library.

Required behavior: Return a non-null pointer to suitably aligned storage ([basic.stc.dynamic]), or else throw a bad_alloc exception. This requirement is binding on a replacement version of this function.

Default behavior:

• (4.1)

  Executes a loop: Within the loop, the function first attempts to allocate the requested storage. Whether the attempt involves a call to the Standard C library function malloc is unspecified.

• (4.2)

  Returns a pointer to the allocated storage if the attempt is successful. Otherwise, if the current new_handler ([get.new.handler]) is a null pointer value, throws bad_alloc.

• (4.3)

  Otherwise, the function calls the current new_handler function ([new.handler]). If the called function returns, the loop repeats.

• (4.4)

  The loop terminates when an attempt to allocate the requested storage is successful or when a called new_handler function does not return.

Effects: Same as above, except that it is called by a placement version of a new-expression when a C++ program prefers a null pointer result as an error indication, instead of a bad_alloc exception.

Replaceable: a C++ program may define a function with this function signature that displaces the default version defined by the C++ standard library.

Required behavior: Return a non-null pointer to suitably aligned storage ([basic.stc.dynamic]), or else return a null pointer. This nothrow version of operator new returns a pointer obtained as if acquired from the (possibly replaced) ordinary version. This requirement is binding on a replacement version of this function.

Default behavior: Calls operator new(size). If the call returns normally, returns the result of that call. Otherwise, returns a null pointer.

[ Example:

T* p1 = new T;                  // throws bad_alloc if it fails
T* p2 = new(nothrow) T;         // returns nullptr if it fails

 — end example ]

Effects: The deallocation function ([basic.stc.dynamic.deallocation]) called by a delete-expression to render the value of ptr invalid.

Replaceable: a C++ program may define a function with signature void operator delete(void* ptr) noexcept that displaces the default version defined by the C++ standard library. If this function (without size parameter) is defined, the program should also define void operator delete(void* ptr, std::size_t size) noexcept. If this function with size parameter is defined, the program shall also define the version without the size parameter. [ Note: The default behavior below may change in the future, which will require replacing both deallocation functions when replacing the allocation function.  — end note ]

Requires: ptr shall be a null pointer or its value shall be a value returned by an earlier call to the (possibly replaced) operator new(std::size_t) or operator new(std::size_t,const std::nothrow_t&) which has not been invalidated by an intervening call to operator delete(void*).

Requires: If an implementation has strict pointer safety ([basic.stc.dynamic.safety]) then ptr shall be a safely-derived pointer.

Requires: If present, the std::size_t size argument shall equal the size argument passed to the allocation function that returned ptr.

Required behavior: Calls to operator delete(void* ptr, std::size_t size) may be changed to calls to operator delete(void* ptr) without affecting memory allocation. [ Note: A conforming implementation is for operator delete(void* ptr, std::size_t size) to simply call operator delete(ptr).  — end note ]

Default behavior: the function operator delete(void* ptr, std::size_t size) calls operator delete(ptr). [ Note: See the note in the above Replaceable paragraph.  — end note ]

Default behavior: If ptr is null, does nothing. Otherwise, reclaims the storage allocated by the earlier call to operator new.

Remarks: It is unspecified under what conditions part or all of such reclaimed storage will be allocated by subsequent calls to operator new or any of calloc, malloc, or realloc, declared in <cstdlib>.

Effects: The deallocation function ([basic.stc.dynamic.deallocation]) called by the implementation to render the value of ptr invalid when the constructor invoked from a nothrow placement version of the new-expression throws an exception.

Replaceable: a C++ program may define a function with signature void operator delete(void* ptr, const std::nothrow_t&) noexcept that displaces the default version defined by the C++ standard library. If this function (without size parameter) is defined, the program should also define void operator delete(void* ptr, std::size_t size, const std::nothrow_t&) noexcept. If this function with size parameter is defined, the program shall also define the version without the size parameter. [ Note: The default behavior below may change in the future, which will require replacing both deallocation functions when replacing the allocation function.  — end note ]

Requires: If an implementation has strict pointer safety ([basic.stc.dynamic.safety]) then ptr shall be a safely-derived pointer.

Requires: If present, the std::size_t size argument must equal the size argument passed to the allocation function that returned ptr.

Required behavior: Calls to operator delete(void* ptr, std::size_t size, const std::nothrow_t&) may be changed to calls to operator delete(void* ptr, const std::nothrow_t&) without affecting memory allocation. [ Note: A conforming implementation is for operator delete(void* ptr, std::size_t size, const std::nothrow_t&) to simply call operator delete(void* ptr, const std::nothrow_t&).  — end note ]

Default behavior: operator delete(void* ptr, std::size_t size, const std::nothrow_t&) calls operator delete(ptr, std::nothrow), and operator delete(void* ptr, const std::nothrow_t&) calls operator delete(ptr).

Effects: The allocation function ([basic.stc.dynamic.allocation]) called by the array form of a new-expression ([expr.new]) to allocate size bytes of storage suitably aligned to represent any array object of that size or smaller.227

Replaceable: a C++ program can define a function with this function signature that displaces the default version defined by the C++ standard library.

Required behavior: Same as for operator new(std::size_t). This requirement is binding on a replacement version of this function.

Default behavior: Returns operator new(size).

Effects: Same as above, except that it is called by a placement version of a new-expression when a C++ program prefers a null pointer result as an error indication, instead of a bad_alloc exception.

Replaceable: a C++ program can define a function with this function signature that displaces the default version defined by the C++ standard library.

Required behavior: Return a non-null pointer to suitably aligned storage ([basic.stc.dynamic]), or return a null pointer. This requirement is binding on a replacement version of this function.

Default behavior: Calls operator new[](size). If the call returns normally, returns the result of that call. Otherwise, returns a null pointer.

Effects: The deallocation function ([basic.stc.dynamic.deallocation]) called by the array form of a delete-expression to render the value of ptr invalid.

Replaceable: a C++ program can define a function with signature void operator delete[](void* ptr) noexcept that displaces the default version defined by the C++ standard library. If this function (without size parameter) is defined, the program should also define void operator delete[](void* ptr, std::size_t size) noexcept. If this function with size parameter is defined, the program shall also define the version without the size parameter. [ Note: The default behavior below may change in the future, which will require replacing both deallocation functions when replacing the allocation function.  — end note ]

Requires: ptr shall be a null pointer or its value shall be the value returned by an earlier call to operator new[](std::size_t) or operator new[](std::size_t,const std::nothrow_t&) which has not been invalidated by an intervening call to operator delete[](void*).

Requires: If present, the std::size_t size argument must equal the size argument passed to the allocation function that returned ptr.

Required behavior: Calls to operator delete[](void* ptr, std::size_t size) may be changed to calls to operator delete[](void* ptr) without affecting memory allocation. [ Note: A conforming implementation is for operator delete[](void* ptr, std::size_t size) to simply call operator delete[](void* ptr).  — end note ]

Requires: If an implementation has strict pointer safety ([basic.stc.dynamic.safety]) then ptr shall be a safely-derived pointer.

Default behavior: operator delete[](void* ptr, std::size_t size) calls operator delete[](ptr), and operator delete[](void* ptr) calls operator delete(ptr).

Effects: The deallocation function ([basic.stc.dynamic.deallocation]) called by the implementation to render the value of ptr invalid when the constructor invoked from a nothrow placement version of the array new-expression throws an exception.

Replaceable: a C++ program may define a function with signature void operator delete[](void* ptr, const std::nothrow_t&) noexcept that displaces the default version defined by the C++ standard library. If this function (without size parameter) is defined, the program should also define void operator delete[](void* ptr, std::size_t size, const std::nothrow_t&) noexcept. If this function with size parameter is defined, the program shall also define the version without the size parameter. [ Note: The default behavior below may change in the future, which will require replacing both deallocation functions when replacing the allocation function.  — end note ]

Requires: If an implementation has strict pointer safety ([basic.stc.dynamic.safety]) then ptr shall be a safely-derived pointer.

Requires: If present, the std::size_t size argument must equal the size argument passed to the allocation function that returned ptr.

Required behavior: Calls to operator delete[](void* ptr, std::size_t size, const std::nothrow_t&) may be changed to calls to operator delete[](void* ptr, const std::nothrow_t&) without affecting memory allocation. [ Note: A conforming implementation is for operator delete[](void* ptr, std::size_t size, const std::nothrow_t&) to simply call operator delete[](void* ptr, const std::nothrow_t&).  — end note ]

Default behavior: operator delete[](void* ptr, std::size_t size, const std::nothrow_t&) calls operator delete[](ptr, std::nothrow), and operator delete[](void* ptr, const std::nothrow_t&) calls operator delete[](ptr).

Returns: ptr.

Remarks: Intentionally performs no other action.

[ Example: This can be useful for constructing an object at a known address:

void* place = operator new(sizeof(Something));
Something* p = new (place) Something();

 — end example ]

Returns: ptr.

Remarks: Intentionally performs no other action.

Effects: Intentionally performs no action.

Requires: If an implementation has strict pointer safety ([basic.stc.dynamic.safety]) then ptr shall be a safely-derived pointer.

Remarks: Default function called when any part of the initialization in a placement new expression that invokes the library's non-array placement operator new terminates by throwing an exception ([expr.new]).

Effects: Intentionally performs no action.

Requires: If an implementation has strict pointer safety ([basic.stc.dynamic.safety]) then ptr shall be a safely-derived pointer.

Remarks: Default function called when any part of the initialization in a placement new expression that invokes the library's array placement operator new terminates by throwing an exception ([expr.new]).

Effects: Constructs an object of class bad_alloc.

Remarks: The result of calling what() on the newly constructed object is implementation-defined.

Effects: Copies an object of class bad_alloc.

Returns: An implementation-defined ntbs.

Effects: constructs an object of class bad_array_new_length.

Remarks: the result of calling what() on the newly constructed object is implementation-defined.

The type of a handler function to be called by operator new() or operator new[]() ([new.delete]) when they cannot satisfy a request for additional storage.

Required behavior: A new_handler shall perform one of the following:

• (2.1)

  make more storage available for allocation and then return;

• (2.2)

  throw an exception of type bad_alloc or a class derived from bad_alloc;

• (2.3)

  terminate execution of the program without returning to the caller;

Effects: Establishes the function designated by new_p as the current new_handler.

Returns: The previous new_handler.

Remarks: The initial new_handler is a null pointer.

Returns: The current new_handler. [ Note: This may be a null pointer value.  — end note ]

The type of a handler function to be called by std::terminate() when terminating exception processing.

Required behavior: A terminate_handler shall terminate execution of the program without returning to the caller.

Default behavior: The implementation's default terminate_handler calls abort().

Effects: Establishes the function designated by f as the current handler function for terminating exception processing.

Remarks: It is unspecified whether a null pointer value designates the default terminate_handler.

Returns: The previous terminate_handler.

Returns: The current terminate_handler. [ Note: This may be a null pointer value.  — end note ]

Remarks: Called by the implementation when exception handling must be abandoned for any of several reasons ([except.terminate]), in effect immediately after throwing the exception. May also be called directly by the program.

Effects: Calls the current terminate_handler function. [ Note: A default terminate_handler is always considered a callable handler in this context.  — end note ]