Linux Manuals

std::reference_wrapper<T>::reference_wrapper – std::reference_wrapper<T>::reference_wrapper Synopsis template< class U > (1) reference_wrapper( U&& x ) noexcept(/*see below*/) ; reference_wrapper( const reference_wrapper& other ) noexcept; (2) Constructs a new reference wrapper. 1) Converts x to T& as if by T& t = std::forward<U>(x); , then stores a reference to t.This overload only participates in overload resolution if typename…

std::reference_wrapper<T>::operator= – std::reference_wrapper<T>::operator= Synopsis reference_wrapper &operator=(const reference_wrapper<T> &other) noexcept; (since C++ 11) Copy assignment operator. Drops the current reference and stores a reference to other.get(). Parameters other – reference wrapper to copy Return values *this

std::reference_wrapper<T>::get,std::reference_wrapper<T>::operatorT& – std::reference_wrapper<T>::get,std::reference_wrapper<T>::operatorT& Synopsis operator T& () const noexcept; (since C++11) T& get() const noexcept; (since C++11) Returns the stored reference. Parameters (none) Return value The stored reference. See also            calls the stored function operator() (public member function)

std::reference_wrapper – std::reference_wrapper Synopsis Defined in header <functional> template< class T > (since C++11) class reference_wrapper; std::reference_wrapper is a class template that wraps a reference in a copyable, assignable object. It is frequently used as a mechanism to store references inside standard containers (like std::vector) which cannot normally hold references. Specifically, std::reference_wrapper is a CopyConstructible…

std::ref,std::cref – std::ref,std::cref Synopsis Defined in header<functional> template <class T> (1)(since C++ 11) std::reference_wrapper<T> ref(T &t) noexcept; template <class T> (2)(since C++ 11) std::reference_wrapper<T> ref(std::reference_wrapper<T> t) noexcept; template <class T> (3)(since C++ 11) void ref(const T &&) = delete; template <class T> (4)(since C++ 11) std::reference_wrapper<const T> cref(const T &t) noexcept; template <class T> (5)(since…

std::reduce – std::reduce Synopsis Defined in header <numeric> template<class InputIt> typename std::iterator_traits<InputIt>::value_type reduce( (1) (since C++17) InputIt first, InputIt last); template<class ExecutionPolicy, class ForwardIt> typename std::iterator_traits<ForwardIt>::value_type reduce( (2) (since C++17) ExecutionPolicy&& policy, ForwardIt first, ForwardIt last); template<class InputIt, class T> (3) (since C++17) T reduce(InputIt first, InputIt last, T init); template<class ExecutionPolicy, class ForwardIt, class…

std::recursive_timed_mutex::unlock – std::recursive_timed_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_timed_mutex::try_lock_until – std::recursive_timed_mutex::try_lock_until Synopsis template <class Clock, class Duration> (since C++ 11) bool try_lock_until(const std::chrono::time_point<Clock, Duration> &timeout_time); Tries to lock the mutex. Blocks until specified timeout_time has been reached or the lock is acquired, whichever comes first. On successful lock acquisition returns true, otherwise returns false. If timeout_time has already passed, this function behaves like…

std::recursive_timed_mutex::try_lock_for – std::recursive_timed_mutex::try_lock_for Synopsis template <class Rep, class Period> (since C++ 11) bool try_lock_for(const std::chrono::duration<Rep, Period> &timeout_duration); Tries to lock the mutex. Blocks until specified timeout_duration has elapsed or the lock is acquired, whichever comes first. On successful lock acquisition returns true, otherwise returns false. If timeout_duration is less or equal timeout_duration.zero(), the function behaves…

std::recursive_timed_mutex::try_lock – std::recursive_timed_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_timed_mutex::~recursive_timed_mutex – std::recursive_timed_mutex::~recursive_timed_mutex Synopsis ~recursive_timed_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_timed_mutex::native_handle – std::recursive_timed_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_timed_mutex::lock – std::recursive_timed_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_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…