Linux Manuals

std::numeric_limits<T>::has_denorm_loss – std::numeric_limits<T>::has_denorm_loss Synopsis static const bool has_denorm_loss; (until C++ 11) static constexpr bool has_denorm_loss; (since C++ 11) The value of std::numeric_limits<T>::has_denorm_loss is true for all floating-point types T that detect loss of precision when creating a subnormal number as denormalization loss rather than as inexact result (see below). Standard specializations T value of std::numeric_limits<T>::has_denorm_loss…

std::numeric_limits<T>::has_denorm – std::numeric_limits<T>::has_denorm Synopsis static const std::float_denorm_style has_denorm; (until C++ 11) static constexpr std::float_denorm_style has_denorm; (since C++ 11) The value of std::numeric_limits<T>::has_denorm identifies the floating-point types that support subnormal_values. Standard specializations T value of std::numeric_limits<T>::has_denorm /* non-specialized */ std::denorm_absent bool std::denorm_absent char std::denorm_absent signed char std::denorm_absent unsigned char std::denorm_absent wchar_t std::denorm_absent char8_t std::denorm_absent char16_t std::denorm_absent…

std::numeric_limits<T>::epsilon – std::numeric_limits<T>::epsilon Synopsis static T epsilon() throw(); (until C++11) static constexpr T epsilon() noexcept; (since C++11) Returns the machine epsilon, that is, the difference between 1.0 and the next value representable by the floating-point type T. It is only meaningful if std::numeric_limits<T>::is_integer == false. Return value T std::numeric_limits<T>::epsilon() /* non-specialized */ T() bool false…

std::numeric_limits<T>::digits10 – std::numeric_limits<T>::digits10 Synopsis static const int digits10; (until C++ 11) static constexpr int digits10(since C++ 11) The value of std::numeric_limits<T>::digits10 is the number of base-10 digits that can be represented by the type T without change, that is, any number with this many significant decimal digits can be converted to a value of type…

std::numeric_limits<T>::digits – std::numeric_limits<T>::digits Synopsis 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 and the…

std::numeric_limits<T>::denorm_min – std::numeric_limits<T>::denorm_min Synopsis static T denorm_min() throw(); (until C++11) static constexpr T denorm_min() noexcept; (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…

std::numeric_limits – std::numeric_limits Synopsis 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…

std::num_put<CharT,OutputIt>::~num_put – std::num_put<CharT,OutputIt>::~num_put Synopsis Defined in header <locale> protected: ~num_put(); Destructs a std::num_put facet. This destructor is protected and virtual (due to base_class destructor being virtual). An object of type std::num_put, like most facets, can only be destroyed when the last std::locale object that implements this facet goes out of scope or if a user-defined…

std::num_get<CharT,InputIt>::~num_get – std::num_get<CharT,InputIt>::~num_get Synopsis Defined in header <locale> protected: ~num_get(); Destructs a std::num_get facet. This destructor is protected and virtual (due to base_class destructor being virtual). An object of type std::num_get, like most facets, can only be destroyed when the last std::locale object that implements this facet goes out of scope or if a user-defined…

std::nullptr_t – std::nullptr_t Synopsis 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…

std::nullopt_t – std::nullopt_t Synopsis Defined in header <optional> struct nullopt_t; (since C++17) std::nullopt_t is an empty class type used to indicate optional type with uninitialized state. In particular, std::optional has a constructor with nullopt_t as a single argument, which creates an optional that does not contain a value. std::nullopt_t must be a non-aggregate LiteralType and…

std::nullopt – std::nullopt Synopsis Defined in header <optional> inline constexpr nullopt_t nullopt{/*unspecified*/}; (since C++17) std::nullopt is a constant of type std::nullopt_t that is used to indicate optional type with uninitialized state. See also nullopt_t indicator of optional type with uninitialized state           (class) (C++17)

std::nth_element – std::nth_element Synopsis Defined in header<algorithm> template <class RandomIt> (until C++ 20) void nth_element(RandomIt first, RandomIt nth, RandomIt last); template <class RandomIt> (since C++ 20) constexpr void nth_element(RandomIt first, RandomIt nth, RandomIt last); template <class ExecutionPolicy, class RandomIt> void nth_element(ExecutionPolicy &&policy, (2)(since C++ 17) RandomIt first, RandomIt nth, RandomIt last); template <class RandomIt, class…

std::notify_all_at_thread_exit – std::notify_all_at_thread_exit Synopsis Defined in header<condition_variable> void notify_all_at_thread_exit(std::condition_variable &cond, (since C++ 11) std::unique_lock<std::mutex> lk); 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…

std::nothrow_t – std::nothrow_t Synopsis Defined in header<new> struct nothrow_t { }; (until C++ 17) struct nothrow_t { explicit nothrow_t() = default; }; (since C++ 17) std::nothrow_t is an empty class type used to disambiguate the overloads of throwing and non-throwing allocation_functions. See also                an object of type nothrow_t used to select an non-throwing allocation function…

std::nothrow – std::nothrow Synopsis Defined in header<new> extern const std::nothrow_t nothrow; std::nothrow is a constant of type std::nothrow_t used to disambiguate the overloads of throwing and non-throwing allocation_functions. Example // Run this code #include <iostream> #include <new> int main() { try { while (true) { new int[100000000ul]; // throwing overload } } catch (const std::bad_alloc…

std::not_fn – std::not_fn Synopsis Defined in header <functional> template< class F> (since C++17) /*unspecified*/ not_fn( F&& f ); Creates a forwarding call wrapper that returns the negation of the callable object it holds. Parameters f – the object from which the Callable object held by the wrapper is constructed Type requirements – std::decay_t<F> must meet…

std::not_equal_to<void> – std::not_equal_to<void> Synopsis Defined in header<functional> template <> (since C++ 14) class not_equal_to<void>; 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            tests if the two arguments do not compare equal operator() (public member function)  std::not_equal_to<>::operator() template< class T, class…

std::not2 – std::not2 Synopsis Defined in header <functional> template< class Predicate > (until C++14) std::binary_negate<Predicate> not2(const Predicate& pred); template< class Predicate > (since C++14) constexpr std::binary_negate<Predicate> not2(const Predicate& pred); (deprecated in C++17)                                                                       (removed in C++20) not2 is a helper function to create a function object that returns the complement of the binary predicate function passed….

std::not1 – std::not1 Synopsis Defined in header <functional> template< class Predicate > (until C++14) std::unary_negate<Predicate> not1(const Predicate& pred); template< class Predicate > (since C++14) constexpr std::unary_negate<Predicate> not1(const Predicate& pred); (deprecated in C++17)                                                                      (removed in C++20) not1 is a helper function to create a function object that returns the complement of the unary predicate function passed….