std::shared_ptr<T>::get – std::shared_ptr<T>::get Synopsis T* get() const noexcept; (until C++17) element_type* get() const noexcept; (since C++17) Returns the stored pointer. Parameters (none) Return value The stored pointer. Notes A shared_ptr may share ownership of an object while storing a pointer to another object. get() returns the stored pointer, not the managed pointer. Example // Run…
std::shared_ptr – std::shared_ptr Synopsis Defined in header <memory> template< class T > class shared_ptr; (since C++11) std::shared_ptr is a smart pointer that retains shared ownership of an object through a pointer. Several shared_ptr objects may own the same object. The object is destroyed and its memory deallocated when either of the following happens: * the…
std::shared_mutex::unlock_shared – std::shared_mutex::unlock_shared Synopsis void unlock_shared(); (since C++ 17) 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_mutex::unlock – std::shared_mutex::unlock Synopsis void unlock(); (since C++ 17) 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_mutex::try_lock_shared – std::shared_mutex::try_lock_shared Synopsis bool try_lock_shared(); (since C++17) 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_mutex::try_lock – std::shared_mutex::try_lock Synopsis bool try_lock(); (since C++17) 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_mutex::~shared_mutex – std::shared_mutex::~shared_mutex Synopsis ~shared_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_mutex::native_handle – std::shared_mutex::native_handle Synopsis native_handle_type native_handle(); (since C++17) (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::shared_mutex::lock_shared – std::shared_mutex::lock_shared Synopsis void lock_shared(); (since C++ 17) 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_mutex::lock – std::shared_mutex::lock Synopsis void lock(); (since C++ 17) 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_mutex – std::shared_mutex Synopsis Defined in header <shared_mutex> class shared_mutex; (since C++17) The shared_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_mutex has two levels of access: * shared – several…
std::shared_lock<Mutex>::unlock – std::shared_lock<Mutex>::unlock Synopsis void unlock(); (since C++ 14) Unlocks the associated mutex from shared mode. Effectively calls mutex()->unlock_shared() 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_shared() * If there is no associated mutex, std::system_error…
std::shared_lock<Mutex>::try_lock_until – std::shared_lock<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 associated 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. May block for longer than…
std::shared_lock<Mutex>::try_lock_for – std::shared_lock<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 associated mutex in shared mode. 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_shared_for(timeout_duration). This function may…
std::shared_lock<Mutex>::try_lock – std::shared_lock<Mutex>::try_lock Synopsis bool try_lock(); (since C++14) Tries to lock the associated mutex in shared mode without blocking. Effectively calls mutex()->try_lock_shared(). std::system_error is thrown if there is no associated mutex or if the mutex is already locked. Parameters (none) Return value true if the ownership of the mutex has been acquired successfully, false otherwise….
std::shared_lock<Mutex>::swap – std::shared_lock<Mutex>::swap Synopsis template <class Mutex> (since C++ 14) void swap(shared_lock<Mutex> &other) noexcept; 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 specialization of std::swap for shared_lock std::swap(std::shared_lock) (function template)
std::shared_lock<Mutex>::~shared_lock – std::shared_lock<Mutex>::~shared_lock Synopsis ~shared_lock(); (since C++14) Destroys the lock. If *this has an associated mutex ((mutex() returns a non-null pointer) and has acquired ownership of it (owns() returns true), the mutex is unlocked by calling unlock_shared().
std::shared_lock<Mutex>::release – std::shared_lock<Mutex>::release Synopsis mutex_type* release() noexcept; (since C++14) 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::shared_lock<Mutex>::owns_lock – std::shared_lock<Mutex>::owns_lock Synopsis bool owns_lock() const noexcept; (since C++14) Checks whether *this owns a locked mutex or not. Parameters (none) Return value true if *this has an associated mutex and has acquired shared ownership of it, false otherwise. See also tests whether the lock owns its associated mutex operator_bool (public member function)
std::shared_lock<Mutex>::operatorbool – std::shared_lock<Mutex>::operatorbool Synopsis explicit operator bool() const noexcept; (since C++14) 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 shared ownership of it, false otherwise. See also tests whether the lock owns its associated mutex owns_lock (public…