The Linux Manuals (man pages) document is an important part of Linux documents. Linux Manuals are organized as several sections. Each section has a group of commands for a specific area in Linux usage, administration or development.
std::showbase,std::noshowbase – std::showbase,std::noshowbase Synopsis Defined in header <ios> std::ios_base& showbase( std::ios_base& str ); (1) std::ios_base& noshowbase( std::ios_base& str ); (2) 1) enables the showbase flag in the stream str as if by calling str.setf(std::ios_base::showbase) 2) disables the showbase flag in the stream str as if by calling str.unsetf(std::ios_base::showbase) This is an I/O manipulator, it may…
std::shift_left,std::shift_right – std::shift_left,std::shift_right Synopsis Defined in header <algorithm> template< class ForwardIt > constexpr ForwardIt shift_left( ForwardIt first, ForwardIt last, (1) (since C++20) typename std::iterator_traits<ForwardIt>::difference_type n ); template< class ExecutionPolicy, class ForwardIt > ForwardIt shift_left( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, (2) (since C++20) typename std::iterator_traits<ForwardIt>::difference_type n ); template< class ForwardIt > constexpr ForwardIt shift_right( ForwardIt…
std::shared_timed_mutex::unlock_shared – std::shared_timed_mutex::unlock_shared Synopsis void unlock_shared(); (since C++ 14) Releases the mutex from shared ownership by the calling thread. The mutex must be locked by the current thread of execution in shared mode, 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…
std::shared_timed_mutex::unlock – std::shared_timed_mutex::unlock Synopsis void unlock(); (since C++ 14) Unlocks the mutex. 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) Return value (none) Exceptions (none) Notes unlock()…
std::shared_timed_mutex::try_lock_until – std::shared_timed_mutex::try_lock_until Synopsis template <class Clock, class Duration> (since C++ 14) 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::shared_timed_mutex::try_lock_shared_until – std::shared_timed_mutex::try_lock_shared_until Synopsis template <class Clock, class Duration> (since C++ 14) bool try_lock_shared_until(const std::chrono::time_point<Clock, Duration> &timeout_time); Tries to lock the mutex in shared mode. 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…
std::shared_timed_mutex::try_lock_shared_for – std::shared_timed_mutex::try_lock_shared_for Synopsis template <class Rep, class Period> (since C++ 14) bool try_lock_shared_for(const std::chrono::duration<Rep, Period> &timeout_duration); Tries to lock the mutex in shared mode. Blocks until specified timeout_duration has elapsed or the shared lock is acquired, whichever comes first. On successful lock acquisition returns true, otherwise returns false. If timeout_duration is less or equal…
std::shared_timed_mutex::try_lock_shared – std::shared_timed_mutex::try_lock_shared Synopsis bool try_lock_shared(); (since C++14) Tries to lock the mutex in shared mode. 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 currenly exclusively locked by any other thread. Prior unlock() operation on the…
std::shared_timed_mutex::try_lock_for – std::shared_timed_mutex::try_lock_for Synopsis template <class Rep, class Period> (since C++ 14) 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::shared_timed_mutex::try_lock – std::shared_timed_mutex::try_lock Synopsis bool try_lock(); (since C++14) 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. If try_lock is called by a thread that already…
std::shared_timed_mutex::~shared_timed_mutex – std::shared_timed_mutex::~shared_timed_mutex Synopsis ~shared_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::shared_timed_mutex::lock_shared – std::shared_timed_mutex::lock_shared Synopsis void lock_shared(); (since C++ 14) Acquires shared ownership of the mutex. If another thread is holding the mutex in exclusive ownership, a call to lock_shared will block execution until shared ownership can be acquired. If lock_shared is called by a thread that already owns the mutex in any mode (exclusive or…
std::shared_timed_mutex::lock – std::shared_timed_mutex::lock Synopsis void lock(); (since C++ 14) Locks the mutex. If another thread has already locked the mutex, a call to lock will block execution until the lock is acquired. If lock is called by a thread that already owns the mutex in any mode (shared or exclusive), the behavior is undefined. Prior…
std::shared_timed_mutex – std::shared_timed_mutex Synopsis Defined in header <shared_mutex> class shared_timed_mutex; (since C++14) The shared_timed_mutex class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads. In contrast to other mutex types which facilitate exclusive access, a shared_timed_mutex has two levels of access: * shared – several…
std::shared_ptr<T>::use_count – std::shared_ptr<T>::use_count Synopsis long use_count() const noexcept; Returns the number of different shared_ptr instances (this included) managing the current object. If there is no managed object, 0 is returned. In multithreaded environment, the value returned by use_count is approximate (typical implementations use a memory_order_relaxed load) Parameters (none) Return value the number of shared_ptr instances…
std::shared_ptr<T>::unique – std::shared_ptr<T>::unique Synopsis bool unique() const noexcept; (deprecated in C++17) (removed in C++20) Checks if *this is the only shared_ptr instance managing the current object, i.e. whether use_count() == 1. Parameters (none) Return value true if *this is the only shared_ptr instance managing the current object, false otherwise. Notes This function was deprecated in…
std::shared_ptr<T>::swap – std::shared_ptr<T>::swap Synopsis void swap(shared_ptr &r) noexcept; (since C++ 11) Exchanges the contents of *this and r Parameters r – smart pointer to exchange the contents with Return value (none)
std::shared_ptr<T>::~shared_ptr – std::shared_ptr<T>::~shared_ptr Synopsis ~shared_ptr(); If *this owns an object and it is the last shared_ptr owning it, the object is destroyed through the owned deleter. After the destruction, the smart pointers that shared ownership with *this, if any, will report a use_count() that is one less than its previous value. Notes Unlike std::unique_ptr, the…
std::shared_ptr<T>::reset – std::shared_ptr<T>::reset Synopsis void reset() noexcept; (1)(since C++ 11) template <class Y> (2)(since C++ 11) void reset(Y *ptr); template <class Y, class Deleter> (3)(since C++ 11) void reset(Y *ptr, Deleter d); template <class Y, class Deleter, class Alloc> (4)(since C++ 11) void reset(Y *ptr, Deleter d, Alloc alloc); Replaces the managed object with an…
std::shared_ptr<T>::owner_before – std::shared_ptr<T>::owner_before Synopsis template <class Y> (until C++ 17) bool owner_before(const shared_ptr<Y> &other) const; template <class Y> (since C++ 17) bool owner_before(const shared_ptr<Y> &other) const noexcept; template <class Y> (until C++ 17) bool owner_before(const std::weak_ptr<Y> &other) const; template <class Y> (since C++ 17) bool owner_before(const std::weak_ptr<Y> &other) const noexcept; Checks whether this shared_ptr precedes…