\rSec0[language.support]{Language support library}

\rSec1[support.general]{General}

This Clause describes the function signatures that are called

implicitly, and the types of objects generated implicitly, during the execution

of some \Cpp programs.

It also describes the headers that declare these function

signatures and define any related types.

The following subclauses describe

common type definitions used throughout the library,

characteristics of the predefined types,

functions supporting start and termination of a \Cpp program,

support for dynamic memory management,

support for dynamic type identification,

support for exception processing, support for initializer lists,

and other runtime support,

as summarized in Table~\ref{tab:lang.sup.lib.summary}.

\begin{libsumtab}{Language support library summary}{tab:lang.sup.lib.summary}

\ref{support.types} & Common definitions & \tcode{<cstddef>} \\

& & \tcode{<cstdlib>} \\ \rowsep

\ref{support.limits} & Implementation properties & \tcode{<limits>} \\

& & \tcode{<climits>} \\

& & \tcode{<cfloat>} \\ \rowsep

\ref{cstdint} & Integer types & \tcode{<cstdint>} \\ \rowsep

\ref{support.start.term} & Start and termination & \tcode{<cstdlib>} \\ \rowsep

\ref{support.dynamic} & Dynamic memory management & \tcode{<new>} \\ \rowsep

\ref{support.rtti} & Type identification & \tcode{<typeinfo>} \\ \rowsep

\ref{support.exception} & Exception handling & \tcode{<exception>} \\ \rowsep

\ref{support.initlist} & Initializer lists & \tcode{<initializer_list>} \\ \rowsep

\ref{support.runtime} & Other runtime support & \tcode{<csignal>} \\

& & \tcode{<csetjmp>} \\

& & \tcode{<cstdarg>} \\

& & \tcode{<cstdlib>} \\

\end{libsumtab}

\rSec1[support.types]{Common definitions}

\rSec2[cstddef.syn]{Header \tcode{<cstddef>} synopsis}

\indexlibrary{\idxcode{NULL}}%

\indexlibrary{\idxcode{offsetof}}%

\indexlibrary{\idxcode{ptrdiff_t}}%

\indexlibrary{\idxcode{size_t}}%

\indexlibrary{\idxcode{max_align_t}}%

\indexlibrary{\idxcode{nullptr_t}}%

\indexlibrary{\idxcode{byte}}%

\begin{codeblock}

namespace std {

using ptrdiff_t = @\seebelow@;

using size_t = @\seebelow@;

using max_align_t = @\seebelow@;

using nullptr_t = decltype(nullptr);

enum class byte : unsigned char {};

// \ref{support.types.byteops}, \tcode{byte} type operations

template <class IntType>

constexpr byte& operator<<=(byte& b, IntType shift) noexcept;

template <class IntType>

constexpr byte operator<<(byte b, IntType shift) noexcept;

template <class IntType>

constexpr byte& operator>>=(byte& b, IntType shift) noexcept;

template <class IntType>

constexpr byte operator>>(byte b, IntType shift) noexcept;

constexpr byte& operator|=(byte& l, byte r) noexcept;

constexpr byte operator|(byte l, byte r) noexcept;

constexpr byte& operator&=(byte& l, byte r) noexcept;

constexpr byte operator&(byte l, byte r) noexcept;

constexpr byte& operator^=(byte& l, byte r) noexcept;

constexpr byte operator^(byte l, byte r) noexcept;

constexpr byte operator~(byte b) noexcept;

template <class IntType>

constexpr IntType to_integer(byte b) noexcept;

}

#define NULL @\seebelow@

#define offsetof(P, D) @\seebelow@

\end{codeblock}

The contents and meaning of the header \tcode{<cstddef>} are the same as

the C standard library header \tcode{<stddef.h>},

except that it does not declare the type \tcode{wchar_t},

that it also declares the type \tcode{byte}

and its associated operations~(\ref{support.types.byteops}),

and as noted in

\ref{support.types.nullptr} and

\ref{support.types.layout}.

\xref ISO C 7.19

\rSec2[cstdlib.syn]{Header \tcode{<cstdlib>} synopsis}

\indextext{\idxhdr{cstdlib}}%

\indexlibrary{\idxhdr{cstdlib}}%

\indexlibrary{\idxcode{EXIT_FAILURE}}%

\indexlibrary{\idxcode{EXIT_SUCCESS}}%

\indexlibrary{\idxcode{MB_CUR_MAX}}%

\indexlibrary{\idxcode{NULL}}%

\indexlibrary{\idxcode{RAND_MAX}}%

\indexlibrary{\idxcode{_Exit}}%

\indexlibrary{\idxcode{abort}}%

\indexlibrary{\idxcode{abs}}%

\indexlibrary{\idxcode{aligned_alloc}}%

\indexlibrary{\idxcode{at_quick_exit}}%

\indexlibrary{\idxcode{atexit}}%

\indexlibrary{\idxcode{atof}}%

\indexlibrary{\idxcode{atoi}}%

\indexlibrary{\idxcode{atol}}%

\indexlibrary{\idxcode{atoll}}%

\indexlibrary{\idxcode{bsearch}}%

\indexlibrary{\idxcode{calloc}}%

\indexlibrary{\idxcode{div}}%

\indexlibrary{\idxcode{div_t}}%

\indexlibrary{\idxcode{exit}}%

\indexlibrary{\idxcode{free}}%

\indexlibrary{\idxcode{getenv}}%

\indexlibrary{\idxcode{labs}}%

\indexlibrary{\idxcode{ldiv}}%

\indexlibrary{\idxcode{ldiv_t}}%

\indexlibrary{\idxcode{llabs}}%

\indexlibrary{\idxcode{lldiv}}%

\indexlibrary{\idxcode{lldiv_t}}%

\indexlibrary{\idxcode{malloc}}%

\indexlibrary{\idxcode{mblen}}%

\indexlibrary{\idxcode{mbstowcs}}%

\indexlibrary{\idxcode{mbtowc}}%

\indexlibrary{\idxcode{qsort}}%

\indexlibrary{\idxcode{quick_exit}}%

\indexlibrary{\idxcode{rand}}%

\indexlibrary{\idxcode{realloc}}%

\indexlibrary{\idxcode{size_t}}%

\indexlibrary{\idxcode{srand}}%

\indexlibrary{\idxcode{strtod}}%

\indexlibrary{\idxcode{strtof}}%

\indexlibrary{\idxcode{strtol}}%

\indexlibrary{\idxcode{strtold}}%

\indexlibrary{\idxcode{strtoll}}%

\indexlibrary{\idxcode{strtoul}}%

\indexlibrary{\idxcode{strtoull}}%

\indexlibrary{\idxcode{system}}%

\indexlibrary{\idxcode{wcstombs}}%

\indexlibrary{\idxcode{wctomb}}%

\begin{codeblock}

namespace std {

using size_t = @\seebelow@;

using div_t = @\seebelow@;

using ldiv_t = @\seebelow@;

using lldiv_t = @\seebelow@;

}

#define NULL @\seebelow@

#define EXIT_FAILURE @\seebelow@

#define EXIT_SUCCESS @\seebelow@

#define RAND_MAX @\seebelow@

#define MB_CUR_MAX @\seebelow@

namespace std {

// Exposition-only function type aliases

extern "C" using @\placeholdernc{c-atexit-handler}@ = void(); // \expos

extern "C++" using @\placeholdernc{atexit-handler}@ = void(); // \expos

extern "C" using @\placeholdernc{c-compare-pred}@ = int(const void*, const void*); // \expos

extern "C++" using @\placeholdernc{compare-pred}@ = int(const void*, const void*); // \expos

// \ref{support.start.term}, start and termination

[[noreturn]] void abort() noexcept;

int atexit(@\placeholder{c-atexit-handler}@* func) noexcept;

int atexit(@\placeholder{atexit-handler}@* func) noexcept;

int at_quick_exit(@\placeholder{c-atexit-handler}@* func) noexcept;

int at_quick_exit(@\placeholder{atexit-handler}@* func) noexcept;

[[noreturn]] void exit(int status);

[[noreturn]] void _Exit(int status) noexcept;

[[noreturn]] void quick_exit(int status) noexcept;

char* getenv(const char* name);

int system(const char* string);

// \ref{c.malloc}, C library memory allocation

void* aligned_alloc(size_t alignment, size_t size);

void* calloc(size_t nmemb, size_t size);

void free(void* ptr);

void* malloc(size_t size);

void* realloc(void* ptr, size_t size);

double atof(const char* nptr);

int atoi(const char* nptr);

long int atol(const char* nptr);

long long int atoll(const char* nptr);

double strtod(const char* nptr, char** endptr);

float strtof(const char* nptr, char** endptr);

long double strtold(const char* nptr, char** endptr);

long int strtol(const char* nptr, char** endptr, int base);

long long int strtoll(const char* nptr, char** endptr, int base);

unsigned long int strtoul(const char* nptr, char** endptr, int base);

unsigned long long int strtoull(const char* nptr, char** endptr, int base);

// \ref{c.mb.wcs}, multibyte / wide string and character conversion functions

int mblen(const char* s, size_t n);

int mbtowc(wchar_t* pwc, const char* s, size_t n);

int wctomb(char* s, wchar_t wchar);

size_t mbstowcs(wchar_t* pwcs, const char* s, size_t n);

size_t wcstombs(char* s, const wchar_t* pwcs, size_t n);

// \ref{alg.c.library}, C standard library algorithms

void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,

@\placeholder{c-compare-pred}@*@\itcorr[-1]@ compar);

void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,

@\placeholder{compare-pred}@*@\itcorr[-1]@ compar);

void qsort(void* base, size_t nmemb, size_t size, @\placeholder{c-compare-pred}@*@\itcorr[-1]@ compar);

void qsort(void* base, size_t nmemb, size_t size, @\placeholder{compare-pred}@*@\itcorr[-1]@ compar);

// \ref{c.math.rand}, low-quality random number generation

int rand();

void srand(unsigned int seed);

// \ref{c.math.abs}, absolute values

int abs(int j);

long int abs(long int j);

long long int abs(long long int j);

float abs(float j);

double abs(double j);

long double abs(long double j);

long int labs(long int j);

long long int llabs(long long int j);

div_t div(int numer, int denom);

ldiv_t div(long int numer, long int denom); // see \ref{library.c}

lldiv_t div(long long int numer, long long int denom); // see \ref{library.c}

ldiv_t ldiv(long int numer, long int denom);

lldiv_t lldiv(long long int numer, long long int denom);

}

\end{codeblock}

The contents and meaning of the header \tcode{<cstdlib>} are the same as

the C standard library header \tcode{<stdlib.h>},

except that it does not declare the type \tcode{wchar_t},

and except as noted in

\ref{support.types.nullptr},

\ref{support.types.layout},

\ref{support.start.term},

\ref{c.malloc},

\ref{c.mb.wcs},

\ref{alg.c.library},

\ref{c.math.rand}, and

\ref{c.math.abs}.

\begin{note}

Several functions have additional overloads in this International Standard,

but they have the same behavior as in the C standard library~(\ref{library.c}).

\end{note}

\xref ISO C 7.22

\rSec2[support.types.nullptr]{Null pointers}

\indexlibrary{\idxcode{nullptr_t}}%

The type \tcode{nullptr_t} is a synonym

for the type of a \tcode{nullptr} expression, and it

has the characteristics

described in~\ref{basic.fundamental} and~\ref{conv.ptr}.

\begin{note}

Although \tcode{nullptr}'s address cannot be taken, the address of another

\tcode{nullptr_t} object that is an lvalue can be taken.

\end{note}

The macro

\indexlibrary{\idxcode{NULL}}%

\tcode{NULL}

is an \impldef{definition of \tcode{NULL}} null pointer constant.%

\footnote{Possible definitions include

\tcode{0}

and

\tcode{0L},

but not

\tcode{(void*)0}.}

\rSec2[support.types.layout]{Sizes, alignments, and offsets}

The macro

\indexlibrary{\idxcode{offsetof}}%

\tcode{offsetof(\placeholder{type}, \placeholder{member-designator})}

has the same semantics as the corresponding macro in

the C standard library header \tcode{<stddef.h>}, but

accepts a restricted set of \tcode{\placeholder{type}}

arguments in this International Standard.

Use of the \tcode{offsetof} macro with a \tcode{\placeholder{type}}

other than a standard-layout class (Clause~\ref{class})

is conditionally-supported.\footnote{Note that \tcode{offsetof}

is required to work as specified even if unary

\tcode{operator\&}

is overloaded for any of the types involved.}

The expression \tcode{offsetof(\placeholder{type}, \placeholder{member-designator})}

is never type-dependent~(\ref{temp.dep.expr}) and it is

value-dependent~(\ref{temp.dep.constexpr}) if and only if \tcode{\placeholder{type}} is

dependent. The result of applying the \tcode{offsetof} macro to

a static data member or a function member is undefined.

No operation invoked by the \tcode{offsetof} macro shall throw an exception and

\tcode{noexcept(offsetof(\placeholder{type}, \placeholder{member-designator}))} shall be \tcode{true}.

The type \tcode{ptrdiff_t} is an

\impldef{type of \tcode{ptrdiff_t}}

signed integer type that can

hold the difference of two subscripts in an array object, as described in~\ref{expr.add}.

The type \tcode{size_t} is an

\impldef{type of \tcode{size_t}}

unsigned integer type that is large enough

to contain the size in bytes of any object.

\begin{note}

It is recommended that implementations choose types for \tcode{ptrdiff_t} and \tcode{size_t}

whose integer conversion ranks~(\ref{conv.rank}) are no greater than that of

\tcode{signed long int} unless a larger size is necessary to contain all the possible values.

\end{note}

The type

\indexlibrary{\idxcode{max_align_t}}%

\tcode{max_align_t} is a POD type whose alignment requirement

is at least as great as that of every scalar type, and whose alignment

requirement is supported in every context.

\xref Alignment~(\ref{basic.align}), Sizeof~(\ref{expr.sizeof}), Additive

operators~(\ref{expr.add}), Free store~(\ref{class.free}), and ISO C~7.19.

\rSec2[support.types.byteops]{\tcode{byte} type operations}

\indexlibrarymember{operator<<=}{byte}%

\begin{itemdecl}

template <class IntType>

constexpr byte& operator<<=(byte& b, IntType shift) noexcept;

\end{itemdecl}

\begin{itemdescr}

\pnum \remarks This function shall not participate in overload resolution unless

\tcode{is_integral_v<IntType>} is \tcode{true}.

\pnum \effects Equivalent to:

\tcode{return b = byte(static_cast<unsigned char>(b) << shift);}

\end{itemdescr}

\indexlibrarymember{operator<<}{byte}%

\begin{itemdecl}

template <class IntType>

constexpr byte operator<<(byte b, IntType shift) noexcept;

\end{itemdecl}

\begin{itemdescr}

\pnum \remarks This function shall not participate in overload resolution unless

\tcode{is_integral_v<IntType>} is \tcode{true}.

\pnum \effects Equivalent to:

\tcode{return byte(static_cast<unsigned char>(b) << shift);}

\end{itemdescr}

\indexlibrarymember{operator>>=}{byte}%

\begin{itemdecl}

template <class IntType>

constexpr byte& operator>>=(byte& b, IntType shift) noexcept;

\end{itemdecl}

\begin{itemdescr}

\pnum \remarks This function shall not participate in overload resolution unless

\tcode{is_integral_v<IntType>} is \tcode{true}.

\pnum \effects Equivalent to:

\tcode{return b = byte(static_cast<unsigned char>(b) >> shift);}

\end{itemdescr}

\indexlibrarymember{operator>>}{byte}%

\begin{itemdecl}

template <class IntType>

constexpr byte operator>>(byte b, IntType shift) noexcept;

\end{itemdecl}

\begin{itemdescr}

\pnum \remarks This function shall not participate in overload resolution unless

\tcode{is_integral_v<IntType>} is \tcode{true}.

\pnum \effects Equivalent to:

\tcode{return byte(static_cast<unsigned char>(b) >> shift);}

\end{itemdescr}

\indexlibrarymember{operator"|=}{byte}%

\begin{itemdecl}

constexpr byte& operator|=(byte& l, byte r) noexcept;

\end{itemdecl}

\begin{itemdescr}

\pnum \effects Equivalent to:

\begin{codeblock}

return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));

\end{codeblock}

\end{itemdescr}

\indexlibrarymember{operator"|}{byte}%

\begin{itemdecl}

constexpr byte operator|(byte l, byte r) noexcept;

\end{itemdecl}

\begin{itemdescr}

\pnum \effects Equivalent to:

\begin{codeblock}

return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));

\end{codeblock}

\end{itemdescr}

\indexlibrarymember{operator\&=}{byte}%

\begin{itemdecl}

constexpr byte& operator&=(byte& l, byte r) noexcept;

\end{itemdecl}

\begin{itemdescr}

\pnum \effects Equivalent to:

\begin{codeblock}

return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));

\end{codeblock}

\end{itemdescr}

\indexlibrarymember{operator\&}{byte}%

\begin{itemdecl}

constexpr byte operator&(byte l, byte r) noexcept;

\end{itemdecl}

\begin{itemdescr}

\pnum \effects Equivalent to:

\begin{codeblock}

return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));

\end{codeblock}

\end{itemdescr}

\indexlibrarymember{operator\caret=}{byte}%

\begin{itemdecl}

constexpr byte& operator^=(byte& l, byte r) noexcept;

\end{itemdecl}

\begin{itemdescr}

\pnum \effects Equivalent to:

\begin{codeblock}

return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));

\end{codeblock}

\end{itemdescr}

\indexlibrarymember{operator\caret}{byte}%

\begin{itemdecl}

constexpr byte operator^(byte l, byte r) noexcept;

\end{itemdecl}

\begin{itemdescr}

\pnum \effects Equivalent to:

\begin{codeblock}

return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));

\end{codeblock}

\end{itemdescr}

\indexlibrarymember{operator\~{}}{byte}%

\begin{itemdecl}

constexpr byte operator~(byte b) noexcept;

\end{itemdecl}

\begin{itemdescr}

\pnum \effects Equivalent to: \tcode{return byte(\~static_cast<unsigned char>(b));}

\end{itemdescr}

\indexlibrarymember{to_integer}{byte}%

\begin{itemdecl}

template <class IntType>

constexpr IntType to_integer(byte b) noexcept;

\end{itemdecl}

\begin{itemdescr}

\pnum \remarks This function shall not participate in overload resolution unless

\tcode{is_integral_v<IntType>} is \tcode{true}.

\pnum \effects Equivalent to: \tcode{return IntType(b);}

\end{itemdescr}

\rSec1[support.limits]{Implementation properties}

\rSec2[support.limits.general]{General}

The headers

\tcode{<limits>}~(\ref{limits.syn}),

\tcode{<climits>}~(\ref{climits.syn}), and

\tcode{<cfloat>}~(\ref{cfloat.syn})

supply characteristics of imple\-mentation-dependent

arithmetic types~(\ref{basic.fundamental}).

\rSec2[limits.syn]{Header \tcode{<limits>} synopsis}

\indextext{\idxhdr{limits}}%

\indexlibrary{\idxhdr{limits}}%

\indextext{\idxcode{numeric_limits}}%

\indexlibrary{\idxcode{numeric_limits}}%

\indexlibrary{\idxcode{float_round_style}}%

\indexlibrary{\idxcode{float_denorm_style}}%

\begin{codeblock}

namespace std {

// \ref{fp.style}, floating-point type properties

enum float_round_style;

enum float_denorm_style;

// \ref{numeric.limits}, class template \tcode{numeric_limits}

template<class T> class numeric_limits;

template<> class numeric_limits<bool>;

template<> class numeric_limits<char>;

template<> class numeric_limits<signed char>;

template<> class numeric_limits<unsigned char>;

template<> class numeric_limits<char16_t>;

template<> class numeric_limits<char32_t>;

template<> class numeric_limits<wchar_t>;

template<> class numeric_limits<short>;

template<> class numeric_limits<int>;

template<> class numeric_limits<long>;

template<> class numeric_limits<long long>;

template<> class numeric_limits<unsigned short>;

template<> class numeric_limits<unsigned int>;

template<> class numeric_limits<unsigned long>;

template<> class numeric_limits<unsigned long long>;

template<> class numeric_limits<float>;

template<> class numeric_limits<double>;

template<> class numeric_limits<long double>;

}

\end{codeblock}

\rSec2[fp.style]{Floating-point type properties}

\rSec3[round.style]{Type \tcode{float_round_style}}

\indexlibrary{\idxcode{float_round_style}}%

\begin{codeblock}

namespace std {

enum float_round_style {

round_indeterminate = -1,

round_toward_zero = 0,

round_to_nearest = 1,

round_toward_infinity = 2,

round_toward_neg_infinity = 3

};

}

\end{codeblock}

The rounding mode for floating-point arithmetic is characterized by the

values:

\begin{itemize}

\indexlibrary{\idxcode{round_indeterminate}}%

\tcode{round_indeterminate}

if the rounding style is indeterminable

\indexlibrary{\idxcode{round_toward_zero}}%

\tcode{round_toward_zero}

if the rounding style is toward zero

\indexlibrary{\idxcode{round_to_nearest}}%

\tcode{round_to_nearest}

if the rounding style is to the nearest representable value

\indexlibrary{\idxcode{round_toward_infinity}}%

\tcode{round_toward_infinity}

if the rounding style is toward infinity

\indexlibrary{\idxcode{round_toward_neg_infinity}}%

\tcode{round_toward_neg_infinity}

if the rounding style is toward negative infinity

\end{itemize}

\rSec3[denorm.style]{Type \tcode{float_denorm_style}}

\indexlibrary{\idxcode{float_denorm_style}}%

\begin{codeblock}

namespace std {

enum float_denorm_style {

denorm_indeterminate = -1,

denorm_absent = 0,

denorm_present = 1

};

}

\end{codeblock}

\indextext{denormalized value|see{number, subnormal}}%

\indextext{value!denormalized|see{number, subnormal}}%

\indextext{subnormal number|see{number, subnormal}}%

\indextext{number!subnormal}%

The presence or absence of subnormal numbers (variable number of exponent bits)

is characterized by the values:

\begin{itemize}

\indexlibrary{\idxcode{denorm_indeterminate}}%

\tcode{denorm_indeterminate}

if it cannot be determined whether or not the type allows subnormal values

\indexlibrary{\idxcode{denorm_absent}}%

\tcode{denorm_absent}

if the type does not allow subnormal values

\indexlibrary{\idxcode{denorm_present}}%

\tcode{denorm_present}

if the type does allow subnormal values

\end{itemize}

\rSec2[numeric.limits]{Class template \tcode{numeric_limits}}

The

\indexlibrary{\idxcode{numeric_limits}}%

\tcode{numeric_limits}

class template provides a \Cpp program with information about various properties of

the implementation's representation of the

arithmetic types.

\indexlibrary{\idxcode{numeric_limits}}%

\begin{codeblock}

namespace std {

template<class T> class numeric_limits {

public:

static constexpr bool is_specialized = false;

static constexpr T min() noexcept { return T(); }

static constexpr T max() noexcept { return T(); }

static constexpr T lowest() noexcept { return T(); }

static constexpr int digits = 0;

static constexpr int digits10 = 0;

static constexpr int max_digits10 = 0;

static constexpr bool is_signed = false;

static constexpr bool is_integer = false;

static constexpr bool is_exact = false;

static constexpr int radix = 0;

static constexpr T epsilon() noexcept { return T(); }

static constexpr T round_error() noexcept { return T(); }

static constexpr int min_exponent = 0;

static constexpr int min_exponent10 = 0;

static constexpr int max_exponent = 0;

static constexpr int max_exponent10 = 0;

static constexpr bool has_infinity = false;

static constexpr bool has_quiet_NaN = false;

static constexpr bool has_signaling_NaN = false;

static constexpr float_denorm_style has_denorm = denorm_absent;

static constexpr bool has_denorm_loss = false;

static constexpr T infinity() noexcept { return T(); }

static constexpr T quiet_NaN() noexcept { return T(); }

static constexpr T signaling_NaN() noexcept { return T(); }

static constexpr T denorm_min() noexcept { return T(); }

static constexpr bool is_iec559 = false;

static constexpr bool is_bounded = false;

static constexpr bool is_modulo = false;

static constexpr bool traps = false;

static constexpr bool tinyness_before = false;

static constexpr float_round_style round_style = round_toward_zero;

};

template<class T> class numeric_limits<const T>;

template<class T> class numeric_limits<volatile T>;

template<class T> class numeric_limits<const volatile T>;

}

\end{codeblock}

For all members declared

\tcode{static} \tcode{constexpr}

in the

\tcode{numeric_limits}

template, specializations shall define these values in such a way

that they are usable as

constant expressions.

The default

\tcode{numeric_limits<T>}

template shall have all members, but with 0 or

\tcode{false}

values.

Specializations shall be provided for each

arithmetic type,

both floating-point and integer, including

\tcode{bool}.

The member

\tcode{is_specialized}

shall be

\tcode{true}

for all such specializations of

\tcode{numeric_limits}.

The value of each member of a specialization of

\tcode{numeric_limits} on a cv-qualified type

\tcode{cv T} shall be equal to the value of the corresponding member of

the specialization on the unqualified type \tcode{T}.

Non-arithmetic standard types, such as

\tcode{complex<T>}~(\ref{complex}), shall not have specializations.

\rSec3[numeric.limits.members]{\tcode{numeric_limits} members}

\indextext{signal-safe!\idxcode{numeric_limits} members}%

Each member function defined in this subclause is signal-safe~(\ref{csignal.syn}).

\indexlibrarymember{min}{numeric_limits}%

\begin{itemdecl}

static constexpr T min() noexcept;

\end{itemdecl}

\begin{itemdescr}

Minimum finite value.\footnote{Equivalent to \tcode{CHAR_MIN}, \tcode{SHRT_MIN},

\tcode{FLT_MIN}, \tcode{DBL_MIN}, etc.}

\indextext{number!subnormal}%

For floating types with subnormal numbers, returns the minimum positive

normalized value.

Meaningful for all specializations in which

\tcode{is_bounded != false},

or

\tcode{is_bounded == false \&\& is_signed == false}.

\end{itemdescr}

\indexlibrarymember{max}{numeric_limits}%

\begin{itemdecl}

static constexpr T max() noexcept;

\end{itemdecl}

\begin{itemdescr}

Maximum finite value.\footnote{Equivalent to \tcode{CHAR_MAX}, \tcode{SHRT_MAX},

\tcode{FLT_MAX}, \tcode{DBL_MAX}, etc.}

Meaningful for all specializations in which

\tcode{is_bounded != false}.

\end{itemdescr}

\indexlibrarymember{lowest}{numeric_limits}%

\begin{itemdecl}

static constexpr T lowest() noexcept;

\end{itemdecl}

\begin{itemdescr}

A finite value \tcode{x} such that there is no other finite

value \tcode{y} where \tcode{y < x}.\footnote{\tcode{lowest()} is necessary because not all

floating-point representations have a smallest (most negative) value that is

the negative of the largest (most positive) finite value.}

Meaningful for all specializations in which \tcode{is_bounded != false}.

\end{itemdescr}

\indexlibrarymember{digits}{numeric_limits}%

\begin{itemdecl}

static constexpr int digits;

\end{itemdecl}

\begin{itemdescr}

Number of

\tcode{radix}

digits that can be represented without change.

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

\pnum For floating-point types, the number of \tcode{radix} digits in the

mantissa.\footnote{Equivalent to \tcode{FLT_MANT_DIG}, \tcode{DBL_MANT_DIG},

\tcode{LDBL_MANT_DIG}.} \end{itemdescr}

\indexlibrarymember{digits10}{numeric_limits}%

\begin{itemdecl}

static constexpr int digits10;

\end{itemdecl}

\begin{itemdescr}

Number of base 10 digits that can be represented without

change.\footnote{Equivalent to \tcode{FLT_DIG}, \tcode{DBL_DIG},

\tcode{LDBL_DIG}.}

Meaningful for all specializations in which

\tcode{is_bounded != false}.

\end{itemdescr}

\indexlibrarymember{max_digits10}{numeric_limits}%

\begin{itemdecl}

static constexpr int max_digits10;

\end{itemdecl}

\begin{itemdescr}

Number of base 10 digits required to ensure that values which

differ are always differentiated.

Meaningful for all floating-point types.

\end{itemdescr}

\indexlibrarymember{is_signed}{numeric_limits}%

\begin{itemdecl}

static constexpr bool is_signed;

\end{itemdecl}

\begin{itemdescr}

\tcode{true} if the type is signed.

Meaningful for all specializations.

\end{itemdescr}

\indexlibrarymember{is_integer}{numeric_limits}%

\begin{itemdecl}

static constexpr bool is_integer;

\end{itemdecl}

\begin{itemdescr}

\tcode{true} if the type is integer.

Meaningful for all specializations.

\end{itemdescr}

\indexlibrarymember{is_exact}{numeric_limits}%

\begin{itemdecl}

static constexpr bool is_exact;

\end{itemdecl}

\begin{itemdescr}

\tcode{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.

\end{itemdescr}

\indexlibrarymember{radix}{numeric_limits}%

\begin{itemdecl}

static constexpr int radix;

\end{itemdecl}

\begin{itemdescr}

For floating types, specifies the base or radix of the exponent representation

(often 2).\footnote{Equivalent to \tcode{FLT_RADIX}.}

For integer types, specifies the base of the

representation.\footnote{Distinguishes types with bases other than 2 (e.g.

BCD).}

Meaningful for all specializations.

\end{itemdescr}

\indexlibrarymember{epsilon}{numeric_limits}%

\begin{itemdecl}

static constexpr T epsilon() noexcept;

\end{itemdecl}

\begin{itemdescr}

Machine epsilon: the difference between 1 and the least value greater than 1

that is representable.\footnote{Equivalent to \tcode{FLT_EPSILON}, \tcode{DBL_EPSILON}, \tcode{LDBL_EPSILON}.}

Meaningful for all floating-point types.

\end{itemdescr}

\indexlibrarymember{round_error}{numeric_limits}%

\begin{itemdecl}

static constexpr T round_error() noexcept;

\end{itemdecl}

\begin{itemdescr}

Measure of the maximum rounding error.\footnote{Rounding error is described in

LIA-1

Section 5.2.4 and

Annex C Rationale Section C.5.2.4 --- Rounding and rounding constants.}

\end{itemdescr}

\indexlibrarymember{min_exponent}{numeric_limits}%

\begin{itemdecl}

static constexpr int min_exponent;

\end{itemdecl}

\begin{itemdescr}

Minimum negative integer such that

\tcode{radix}

raised to the power of one less than that integer is a normalized floating-point

number.\footnote{Equivalent to \tcode{FLT_MIN_EXP}, \tcode{DBL_MIN_EXP},

\tcode{LDBL_MIN_EXP}.}

Meaningful for all floating-point types.

\end{itemdescr}

\indexlibrarymember{min_exponent10}{numeric_limits}%

\begin{itemdecl}

static constexpr int min_exponent10;

\end{itemdecl}

\begin{itemdescr}

Minimum negative integer such that 10 raised to that power is in the range

of normalized floating-point numbers.\footnote{Equivalent to

\tcode{FLT_MIN_10_EXP}, \tcode{DBL_MIN_10_EXP}, \tcode{LDBL_MIN_10_EXP}.}

Meaningful for all floating-point types.

\end{itemdescr}

\indexlibrarymember{max_exponent}{numeric_limits}%

\begin{itemdecl}

static constexpr int max_exponent;

\end{itemdecl}

\begin{itemdescr}

Maximum positive integer such that

\tcode{radix}

raised to the power one less than that integer is a representable finite

floating-point number.\footnote{Equivalent to \tcode{FLT_MAX_EXP},

\tcode{DBL_MAX_EXP}, \tcode{LDBL_MAX_EXP}.}

Meaningful for all floating-point types.

\end{itemdescr}

\indexlibrarymember{max_exponent10}{numeric_limits}%

\begin{itemdecl}

static constexpr int max_exponent10;

\end{itemdecl}

\begin{itemdescr}

Maximum positive integer such that 10 raised to that power is in the

range of representable finite floating-point numbers.\footnote{Equivalent to

\tcode{FLT_MAX_10_EXP}, \tcode{DBL_MAX_10_EXP}, \tcode{LDBL_MAX_10_EXP}.}

Meaningful for all floating-point types.

\end{itemdescr}

\indexlibrarymember{has_infinity}{numeric_limits}%

\begin{itemdecl}

static constexpr bool has_infinity;

\end{itemdecl}

\begin{itemdescr}

\tcode{true} if the type has a representation for positive infinity.

Meaningful for all floating-point types.

Shall be

\tcode{true}

for all specializations in which

\tcode{is_iec559 != false}.

\end{itemdescr}

\indexlibrarymember{has_quiet_NaN}{numeric_limits}%

\begin{itemdecl}