Linux Manuals session 3

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…

std::shared_ptr<T>::operatorbool – std::shared_ptr<T>::operatorbool Synopsis explicit operator bool() const noexcept; Checks if *this stores a non-null pointer, i.e. whether get() != nullptr. Parameters (none) Return value true if *this stores a pointer, false otherwise. Notes An empty shared_ptr (where use_count() == 0) may store a non-null pointer accessible by get(), e.g. if it were created using…

std::shared_ptr<T>::operator[] – std::shared_ptr<T>::operator[] Synopsis element_type& operator[]( std::ptrdiff_t idx ) const; (since C++17) Index into the array pointed to by the stored pointer. The behavior is undefined if the stored pointer is null or if idx is negative. If T (the template parameter of shared_ptr) is an array type U[N], idx must be less than N,…

std::shared_ptr<T>::operator*,std::shared_ptr<T>::operator-> – std::shared_ptr<T>::operator*,std::shared_ptr<T>::operator-> Synopsis T& operator*() const noexcept; (1) (since C++11) T* operator->() const noexcept; (2) (since C++11) Dereferences the stored pointer. The behavior is undefined if the stored pointer is null. Parameters (none) Return value 1) The result of dereferencing the stored pointer, i.e., *get() 2) The stored pointer, i.e., get() Remarks When T…

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…