void unlock(); (since C++11) Unlocks the mutex if its level of ownership is 1 (there was exactly one more call to lock() than there were calls to unlock() made by this thread), reduces the level of ownership by 1 otherwise. The mutex must be locked by the current thread of execution, otherwise, the behavior is undefined. This operation synchronizes-with (as defined in std::memory_order) any subsequent lock operation that obtains ownership of the same mutex. Parameters (none). Retur

void lock(); (since C++11) Locks the mutex. If another thread has already locked the mutex, a call to lock will block execution until the lock is acquired. A thread may call lock on a recursive mutex repeatedly. Ownership will only be released after the thread makes a matching number of calls to unlock. The maximum number of levels of ownership is unspecified. An exception of type std::system_error will be thrown if this number is exceeded. Prior unlock() operation on the same mutex syn

Defined in header <complex> template< class T > T real( const complex<T>& z ); (1) (until C++14) template< class T > constexpr T real( const complex<T>& z ); (1) (since C++14) long double real( long double z ); (2) (since C++11) template< class DoubleOrInteger > double real( DoubleOrInteger z ); (3) (since C++11) float real( float z ); (4) (since C++11) Returns the real component of the complex number z, i.e. z

Defined in header <cstdlib> void* realloc( void* ptr, std::size_t new_size ); Reallocates the given area of memory. It must be previously allocated by std::malloc(), std::calloc() or std::realloc() and not yet freed with std::free(), otherwise, the results are undefined. The reallocation is done by either: a) expanding or contracting the existing area pointed to by ptr, if possible. The contents of the area remain unchanged up to the lesser of the new and old sizes. If the

Defined in header <iterator> template <class E> std::reverse_iterator<const E*> rbegin( std::initializer_list<E> il ); (since C++14) The overload of std::rbegin for initializer_list returns an std::reverse_iterator pointing at the last element of il. Parameters il - an initializer_list Return value std::reverse_iterator<const E*>(il.end()). Exceptions (none). Notes This overload is necessary because std::initializer_list does not

Defined in header <iterator> template< class C > auto rbegin( C& c ) -> decltype(c.rbegin()); (1) (since C++14) template< class C > auto rbegin( const C& c ) -> decltype(c.rbegin()); (1) (since C++14) template< class T, size_t N > reverse_iterator<T*> rbegin( T (&array)[N] ); (2) (since C++14) template< class C > auto crbegin( const C& c ) -> decltype(std::rbegin(c)); (3) (since C++14) Returns an i

Defined in header <mutex> class recursive_mutex; (since C++11) The recursive_mutex class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads. recursive_mutex offers exclusive, recursive ownership semantics: A calling thread owns a recursive_mutex for a period of time that starts when it successfully calls either lock or try_lock. During this period, the thread may make additional calls to lock or try

Defined in header <ratio> template< class R1, class R2 > using ratio_subtract = /* see below */; The alias template std::ratio_subtract denotes the result of subtracting two exact rational fractions represented by the std::ratio specializations R1 and R2. The result is a std::ratio specialization std::ratio<U, V>, such that given Num == R1::num * R2::den - R2::num * R1::den and Denom == R1::den * R2::den (computed without arithmetic overflow), U is std::ratio<

raw_storage_iterator& operator++(); raw_storage_iterator operator++(int); Advances the iterator. 1) Pre-increment. Returns the updated iterator. 2) Post-increment. Returns the old value of the iterator. Parameters (none). Return value 1) *this 2) The old value of the iterator.

explicit raw_storage_iterator( OutputIt it ); Initializes the iterator to point to the same value as it points. Parameters it - location to point to