Linux Manuals session 3

std::recursive_timed_mutex – std::recursive_timed_mutex Synopsis Defined in header <mutex> class recursive_timed_mutex; (since C++11) The recursive_timed_mutex class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads. In a manner similar to std::recursive_mutex, recursive_timed_mutex provides exclusive, recursive ownership semantics. In addition, recursive_timed_mutex provides the ability to attempt to…

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

std::recursive_mutex::try_lock – std::recursive_mutex::try_lock Synopsis bool try_lock(); (since C++11) Tries to lock the mutex. Returns immediately. On successful lock acquisition returns true, otherwise returns false. This function is allowed to fail spuriously and return false even if the mutex is not currently locked by any other thread. A thread may call try_lock on a recursive mutex…

std::recursive_mutex::~recursive_mutex – std::recursive_mutex::~recursive_mutex Synopsis ~recursive_mutex(); Destroys the mutex. The behavior is undefined if the mutex is owned by any thread or if any thread terminates while holding any ownership of the mutex. See also

std::recursive_mutex::native_handle – std::recursive_mutex::native_handle Synopsis native_handle_type native_handle(); (since C++11)                                      (optional) Returns the underlying implementation-defined native handle object. Parameters (none) Return value Implementation-defined native handle object. Exceptions Implementation-defined. Example  This section is incomplete  Reason: no example

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

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

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

std::real(std::complex) – std::real(std::complex) Synopsis Defined in header<complex> template <class T> (until C++ 14) T real(const std::complex<T> &z); template <class T> (since C++ 14) constexpr T real(const std::complex<T> &z); float real(float z); template <class DoubleOrInteger> (1)(since C++ 11) double real(DoubleOrInteger z); (until C++ 14) long double real(long double z); (2) constexpr float real(float z); template <class…

std::readable_traits – std::readable_traits Synopsis Defined in header<iterator> template <class I> (1)(since C++ 20) struct readable_traits { }; template <class T> (2)(since C++ 20) struct readable_traits<T *>; template <class I> requires std::is_array_v<I>(3) (since C++ 20) struct readable_traits<I>; template <class T> (4)(since C++ 20) struct readable_traits<const T> : value_type<T> { }; template <class T> requires requires {…

std::rbegin,std::crbegin – std::rbegin,std::crbegin Synopsis Defined in header<iterator> template <class C> (since C++ 14) auto rbegin(C &c) -> decltype(c.rbegin()); (until C++ 17) template <class C> (since C++ 17) constexpr auto rbegin(C &c) -> decltype(c.rbegin()); template <class C> (since C++ 14) auto rbegin(const C &c) -> decltype(c.rbegin()); (until C++ 17) template <class C> (since C++ 17) constexpr…

std::rbegin(std::initializer_list) – std::rbegin(std::initializer_list) Synopsis Defined in header<iterator> template <class E> (since C++ 14) std::reverse_iterator<const E *> rbegin(std::initializer_list<E> il); 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 have…

std::raw_storage_iterator<OutputIt,T>::raw_storage_iterator – std::raw_storage_iterator<OutputIt,T>::raw_storage_iterator Synopsis explicit raw_storage_iterator( OutputIt it ); Initializes the iterator to point to the same value as it points. Parameters it – location to point to

std::ratio_subtract – std::ratio_subtract Synopsis Defined in header <ratio> template< class R1, class R2 > (since C++11) 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…

std::ratio_not_equal – std::ratio_not_equal Synopsis Defined in header<ratio> template <class R1, class R2> (since C++ 11) struct ratio_not_equal : std::integral_constant; If the ratios R1 and R2 are not equal, provides the member constant value equal true. Otherwise, value is false. Helper variable template template< class R1, class R2 > (since C++17) inline constexpr bool ratio_not_equal_v =…

std::ratio_multiply – std::ratio_multiply Synopsis Defined in header <ratio> template< class R1, class R2 > (since C++11) using ratio_multiply = /* see below */; The alias template std::ratio_multiply denotes the result of multiplying 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…

std::ratio_less_equal – std::ratio_less_equal Synopsis Defined in header<ratio> template <class R1, class R2> (since C++ 11) struct ratio_less_equal : std::integral_constant; If the ratio R1 is less than or equal to the ratio R2, provides the member constant value equal true. Otherwise, value is false. Helper variable template template< class R1, class R2 > (since C++17) inline…

std::ratio_less – std::ratio_less Synopsis Defined in header<ratio> template <class R1, class R2> (since C++ 11) struct ratio_less : std::integral_constant; If the ratio R1 is less than the ratio R2, provides the member constant value equal true. Otherwise, value is false. Helper variable template template< class R1, class R2 > (since C++17) inline constexpr bool ratio_less_v…

std::ratio_greater_equal – std::ratio_greater_equal Synopsis Defined in header<ratio> template <class R1, class R2> (since C++ 11) struct ratio_greater_equal : std::integral_constant; If the ratio R1 is greater than or equal to the ratio R2, provides the member constant value equal true. Otherwise, value is false. Helper variable template template< class R1, class R2 > (since C++17) inline…

std::ratio_greater – std::ratio_greater Synopsis Defined in header<ratio> template <class R1, class R2> (since C++ 11) struct ratio_greater : std::integral_constant; If the ratio R1 is greater than than the ratio R2, provides the member constant value equal true. Otherwise, value is false. Helper variable template template< class R1, class R2 > (since C++17) inline constexpr bool…