static const int digits; (until C++11) static constexpr int digits; (since C++11) The value of std::numeric_limits<T>::digits is the number of digits in base-radix that can be represented by the type T without change. For integer types, this is the number of bits not counting the sign bit. For floating-point types, this is the number of digits in the mantissa. Standard specializations T value of std::numeric_limits<T>::digits /* non-specialized */ ​0​ bool

Defined in header <limits> template< class T > class numeric_limits; The numeric_limits class template provides a standardized way to query various properties of arithmetic types (e.g. the largest possible value for type int is std::numeric_limits<int>::max()). This information is provided via specializations of the numeric_limits template. The standard library makes available specializations for all arithmetic types: Defined in header <limits> tem

static T denorm_min(); (until C++11) static constexpr T denorm_min(); (since C++11) Returns the minimum positive subnormal value of the type T, if std::numeric_limits<T>::has_denorm != std::denorm_absent, otherwise returns std::numeric_limits<T>::min(). Only meaningful for floating-point types. Return value T std::numeric_limits<T>::denorm_min() /* non-specialized */ T(); bool false char ​0​ signed char ​0​ unsigned char ​0​ wchar_t

Defined in header <cstddef> typedef decltype(nullptr) nullptr_t; (since C++11) std::nullptr_t is the type of the null pointer literal, nullptr. It is a distinct type that is not itself a pointer type or a pointer to member type. Example If two or more overloads accept different pointer types, an overload for std::nullptr_t is necessary to accept a null pointer argument. #include <cstddef> #include <iostream> void f(int* pi) { std::cout << "Pointer

Defined in header <new> struct nothrow_t {}; std::nothrow_t is an empty class type used to disambiguate the overloads of throwing and non-throwing allocation functions. See also nothrow an object of type nothrow_t used to select an non-throwing allocation function (constant) operator newoperator new[] allocation functions (function)

Defined in header <functional> template<> class not_equal_to<void>; (since C++14) std::not_equal_to<> is a specialization of std::not_equal_to with parameter and return type deduced. Member types Member type Definition is_transparent /* unspecified */ Member functions operator() tests if the two arguments do not compare equal (public member function) std::not_equal_to<>::operator() template< class T, class U> conste

Defined in header <functional> template< class T > struct not_equal_to; (until C++14) template< class T = void > struct not_equal_to; (since C++14) Function object for performing comparisons. Unless specialised, invokes operator!= on type T. Specializations The standard library provides a specialization of std::not_equal_to when T is not specified, which leaves the parameter types and return type to be deduced. not_equal_to<void> function obj

Defined in header <condition_variable> void notify_all_at_thread_exit( std::condition_variable& cond, std::unique_lock<std::mutex> lk ); (since C++11) notify_all_at_thread_exit provides a mechanism to notify other threads that a given thread has completely finished, including destroying all thread_local objects. It operates as follows: Ownership of the previously acquired lock lk is transferred to internal storage. The execution

Defined in header <algorithm> template< class RandomIt > void nth_element( RandomIt first, RandomIt nth, RandomIt last ); (1) template< class RandomIt, class Compare > void nth_element( RandomIt first, RandomIt nth, RandomIt last, Compare comp ); (2) nth_element is a partial sorting algorithm that rearranges elements in [first, last) such that: The element pointed at by nth is changed to whatever element would occur in that position if [first, last) was s

void reset(); (since C++11) Resets the internal state of the distribution object. After a call to this function, the next call to operator() on the distribution object will not be dependent on previous calls to operator(). Parameters (none). Return value (none). Complexity Constant.