size_type max_size() const; Returns the maximum number of elements the container is able to hold due to system or library implementation limitations, i.e. std::distance(begin(), end()) for the largest container. Parameters (none). Return value Maximum number of elements. Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11) Complexity Constant. Notes This value is typically equal to std::numeric_limits<size_type>::max(), and reflects the

reverse_iterator rbegin(); const_reverse_iterator rbegin() const; const_reverse_iterator crbegin() const; (since C++11) Returns a reverse iterator to the first element of the reversed container. It corresponds to the last element of the non-reversed container. Parameters (none). Return value Reverse iterator to the first element. Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11) Complexity Constant. See also rend crend r

Defined in header <cmath> float nextafter( float from, float to ); (1) (since C++11) double nextafter( double from, double to ); (2) (since C++11) long double nextafter( long double from, long double to ); (3) (since C++11) Promoted nextafter( Arithmetic from, Arithmetic to ); (4) (since C++11) float nexttoward( float from, long double to ); (5) (since C++11) double nexttoward( double from, long double to ); (6) (since C++

T* data(); (since {std}) const T* data() const; (since {std}) Returns pointer to the underlying array serving as element storage. The pointer is such that range [data(); data() + size()) is always a valid range, even if the container is empty. Parameters (none). Return value Pointer to the underlying element storage. For non-empty containers, returns &front(). Complexity Constant. Exceptions noexcept specification: noexcept See also front access the first

Defined in header <cfenv> #define FE_DOWNWARD /*implementation defined*/ (since C++11) #define FE_TONEAREST /*implementation defined*/ (since C++11) #define FE_TOWARDZERO /*implementation defined*/ (since C++11) #define FE_UPWARD /*implementation defined*/ (since C++11) Each of these macro constants expands to a nonnegative integer constant expression, which can be used with std::fesetround and std::fegetround to indicate one of the supporte

Defined in header <exception> template< class T > [[noreturn]] void throw_with_nested( T&& t ); (since C++11) If std::remove_reference_t<T> is a non-final non-union class type that is neither std::nested_exception nor derived from std::nested_exception, throws an exception of an unspecified type that is publicly derived from both std::nested_exception and from std::remove_reference_t<T>, and constructed from std::forward<T>(t). The default co

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 #include <iostream> #include <new> int main() { try { while (true) { new int[100000000ul]; // throwing overload } } catch (const std::bad_alloc& e) { std::cout << e.what() << '\n'; }

void lock(); (since C++17) Locks the mutex. If another thread has already locked the mutex, a call to lock will block execution until the lock is acquired. If lock is called by a thread that already owns the mutex in any mode (shared or exclusive), the behavior is undefined. Prior unlock() operation on the same mutex synchronizes-with (as defined in std::memory_order) this operation. Parameters (none). Return value (none). Exceptions Throws std::system_error when errors occur,

Defined in header <random> template< class IntType = int > class geometric_distribution; (since C++11) Produces random non-negative integer values i, distributed according to discrete probability function: P(i|p) = p · (1 − p). i The value represents the number of yes/no trials (each succeeding with probability p) which are necessary to obtain a single success. std::geometric_distribution<>(p) is exactly equivalent to std::negative_binomial_distribution<

Defined in header <cmath> float nanf( const char* arg ); (since C++11) double nan( const char* arg ); (since C++11) long double nanl( const char* arg ); (since C++11) Converts the implementation-defined character string arg into the corresponding quiet NaN value, as if by calling std::strtod, std::strtof, or std::strtold, respectively, as follows: The call std::nan("string") is equivalent to the call std::strtod("NAN(string)", (char**)NULL);. The call std::nan("