Linux Manuals

std::unwrap_reference,std::unwrap_ref_decay – std::unwrap_reference,std::unwrap_ref_decay Synopsis Defined in header<functional> template <class T> (1)(since C++ 20) struct unwrap_reference; template <class T> (2)(since C++ 20) struct unwrap_ref_decay : std::unwrap_reference<std::decay_t<T>> { }; 1) If T is std::reference_wrapper<U> for some type U, provides a member typedef type that names U&; otherwise, provides a member typedef type that names T. 2) If…

std::unordered_set<Key,Hash,KeyEqual,Allocator>::~unordered_set – std::unordered_set<Key,Hash,KeyEqual,Allocator>::~unordered_set Synopsis ~unordered_set(); (since C++11) Destructs the container. The destructors of the elements are called and the used storage is deallocated. Note, that if the elements are pointers, the pointed-to objects are not destroyed. Complexity Linear in the size of the container.

std::unordered_multiset<Key,Hash,KeyEqual,Allocator>::~unordered_multiset – std::unordered_multiset<Key,Hash,KeyEqual,Allocator>::~unordered_multiset Synopsis ~unordered_multiset(); (since C++11) Destructs the container. The destructors of the elements are called and the used storage is deallocated. Note, that if the elements are pointers, the pointed-to objects are not destroyed. Complexity Linear in the size of the container.

std::unordered_multimap<Key,T,Hash,KeyEqual,Allocator>::~unordered_multimap – std::unordered_multimap<Key,T,Hash,KeyEqual,Allocator>::~unordered_multimap Synopsis ~unordered_multimap(); (since C++11) Destructs the container. The destructors of the elements are called and the used storage is deallocated. Note, that if the elements are pointers, the pointed-to objects are not destroyed. Complexity Linear in the size of the container.

std::unordered_map<Key,T,Hash,KeyEqual,Allocator>::~unordered_map – std::unordered_map<Key,T,Hash,KeyEqual,Allocator>::~unordered_map Synopsis ~unordered_map(); (since C++11) Destructs the container. The destructors of the elements are called and the used storage is deallocated. Note, that if the elements are pointers, the pointed-to objects are not destroyed. Complexity Linear in the size of the container.

std::unitbuf,std::nounitbuf – std::unitbuf,std::nounitbuf Synopsis Defined in header <ios> std::ios_base& unitbuf( std::ios_base& str ); (1) std::ios_base& nounitbuf( std::ios_base& str ); (2) Enables or disables automatic flushing of the output stream after any output operation. Has no effect on input. 1) enables the unitbuf flag in the stream str as if by calling str.setf(std::ios_base::unitbuf) 2) disables the…

std::unique_ptr<T,Deleter>::~unique_ptr – std::unique_ptr<T,Deleter>::~unique_ptr Synopsis ~unique_ptr(); (since C++11) If get() == nullptr there are no effects. Otherwise, the owned object is destroyed via get_deleter()(get()). Requires that get_deleter()(get()) does not throw exceptions. Notes Although std::unique_ptr<T> with the default deleter may be constructed with incomplete_type T, the type T must be complete at the point of code where…

std::unique_lock<Mutex>::unlock – std::unique_lock<Mutex>::unlock Synopsis void unlock(); (since C++ 11) Unlocks the associated mutex and releases ownership. std::system_error is thrown if there is no associated mutex or if the mutex is not locked. Parameters (none) Return value (none) Exceptions * Any exceptions thrown by mutex()->unlock() * If there is no associated mutex or the mutex is…

std::unique_lock<Mutex>::~unique_lock – std::unique_lock<Mutex>::~unique_lock Synopsis ~unique_lock(); (since C++11) Destroys the lock. If *this has an associated mutex and has acquired ownership of it, the mutex is unlocked.

std::unique_lock<Mutex>::try_lock_until – std::unique_lock<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 associated 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. May block for longer than until timeout_time has…

std::unique_lock<Mutex>::try_lock_for – std::unique_lock<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 associated 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. Effectively calls mutex()->try_lock_for(timeout_duration). This function may block for longer…

std::unique_lock<Mutex>::try_lock – std::unique_lock<Mutex>::try_lock Synopsis bool try_lock(); (since C++11) Tries to lock the associated mutex without blocking. Effectively calls mutex()->try_lock(). std::system_error is thrown if there is no associated mutex or if the mutex is already locked by this std::unique_lock. Parameters (none) Return value true if the ownership of the mutex has been acquired successfully, false otherwise….

std::unique_lock<Mutex>::swap – std::unique_lock<Mutex>::swap Synopsis void swap(unique_lock &other) noexcept; (since C++ 11) Exchanges the internal states of the lock objects. Parameters other – the lock to swap the state with Return value (none) Example  This section is incomplete  Reason: no example See also std::swap(std::unique_lock) specialization of std::swap for unique_lock                             (function template) (C++11)

std::unique_lock<Mutex>::release – std::unique_lock<Mutex>::release Synopsis mutex_type* release() noexcept; (since C++11) Breaks the association of the associated mutex, if any, and *this. No locks are unlocked. If the *this held ownership of the associated mutex prior to the call, the caller is now responsible to unlock the mutex. Parameters (none) Return value Pointer to the associated mutex…

std::unique_lock<Mutex>::owns_lock – std::unique_lock<Mutex>::owns_lock Synopsis bool owns_lock() const noexcept; (since C++11) Checks whether *this owns a locked mutex or not. Parameters (none) Return value true if *this has an associated mutex and has acquired ownership of it, false otherwise. See also               tests whether the lock owns its associated mutex operator_bool (public member function)

std::unique_lock<Mutex>::operatorbool – std::unique_lock<Mutex>::operatorbool Synopsis explicit operator bool() const noexcept; (since C++11) Checks whether *this owns a locked mutex or not. Effectively calls owns_lock(). Parameters (none) Return value true if *this has an associated mutex and has acquired ownership of it, false otherwise. See also           tests whether the lock owns its associated mutex owns_lock (public member…

std::unique_lock<Mutex>::operator= – std::unique_lock<Mutex>::operator= Synopsis unique_lock& operator=( unique_lock&& other ); (since C++11) Move assignment operator. Replaces the contents with those of other using move semantics. If prior to the call *this has an associated mutex and has acquired ownership of it, the mutex is unlocked. Parameters other – another unique_lock to replace the state with Return…

std::unique_lock<Mutex>::mutex – std::unique_lock<Mutex>::mutex Synopsis mutex_type* mutex() const noexcept; (since C++11) Returns a pointer to the associated mutex, or a null pointer if there is no associated mutex. Parameters (none) Return value Pointer to the associated mutex or a null pointer if there is no associated mutex. Example  This section is incomplete  Reason: no example

std::unique_lock<Mutex>::lock – std::unique_lock<Mutex>::lock Synopsis void lock(); (since C++ 11) Locks the associated mutex. Effectively calls mutex()->lock(). Parameters (none) Return value (none) Exceptions * Any exceptions thrown by mutex()->lock() * If there is no associated mutex, std::system_error with an error code of std::errc::operation_not_permitted * If the mutex is already locked by this unique_lock (in other words,…

std::unique_lock – std::unique_lock Synopsis Defined in header <mutex> template< class Mutex > (since C++11) class unique_lock; The class unique_lock is a general-purpose mutex ownership wrapper allowing deferred locking, time-constrained attempts at locking, recursive locking, transfer of lock ownership, and use with condition variables. The class unique_lock is movable, but not copyable — it meets the…