nested_exception(); (1) (since C++11) nested_exception( const nested_exception& other ) = default; (2) (since C++11) Constructs new nested_exception object. 1) Default constructor. Stores an exception object obtained by calling std::current_exception() within the new nested_exception object. 2) Copy constructor. Initializes the object with the exception stored in other. Parameters other - nested exception to initialize the contents with Exceptions noexcept sp

Declares a named variable as a reference, that is, an alias to an already-existing object or function. Syntax A reference variable declaration is any simple declaration whose declarator has the form. & attr(optional) declarator (1) && attr(optional) declarator (2) (since C++11) 1) Lvalue reference declarator: the declaration S& D; declares D as an lvalue reference to the type determined by decl-specifier-seq S. 2) Rvalue reference declarator: the declaration S

Defined in header <locale> template< class charT > bool isupper( charT ch, const locale& loc ); Checks if the given character is classified as an uppercase alphabetic character by the given locale's std::ctype facet. Parameters ch - character loc - locale Return value Returns true if the character is classified as uppercase, false otherwise. Possible implementation template< class charT > bool isupper( charT ch, const std::locale&

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 > bool is_heap( RandomIt first, RandomIt last ); (1) (since C++11) template< class RandomIt, class Compare > bool is_heap( RandomIt first, RandomIt last, Compare comp ); (2) (since C++11) Checks if the elements in range [first, last) are a max heap. The first version of is_heap uses operator< to compare elements, whereas the second uses the given comparison function comp. Parameters first, last

Defined in header <functional> template< class T = void > struct bit_not; (since C++14) Function object for performing bitwise NOT. Effectively calls operator~ on type T. Specializations The standard library provides a specialization of std::bit_not when T is not specified, which leaves the parameter types and return type to be deduced. bit_not<void> function object implementing ~x deducing argument and return types (class template specialization) (sin

Initialization of a variable provides its initial value at the time of construction. The initial value may be provided in the initializer section of a declarator or a new expression. It also takes place during function calls: function parameters and the function return values are also initialized. For each declarator, the initializer may be one of the following: ( expression-list ) (1) = expression (2) { initializer-list } (3) 1) comma-separated list of arbitrary expressi

Usage alternative operators: as an alternative for &

Defined in header <complex> template< class T > complex<T> proj( const complex<T>& z ); (1) (since C++11) std::complex<long double> proj( long double z ); (2) (since C++11) template< class DoubleOrIngeter > std::complex<double> proj( DoubleOrInteger z ); (3) (since C++11) std::complex<float> proj( float z ); (4) (since C++11) Returns the projection of the complex number z onto the Riemann sphere. For most z, s

Defined in header <iterator> template< class T, class CharT = char, class Traits = std::char_traits<CharT> > class ostream_iterator : public std::iterator<std::output_iterator_tag, void, void, void, void> (until C++17) template< class T, class CharT = char, class Traits = std::char_traits<CharT>> class ostream_iterator; (since C++17) std::ostream_iterato