Defined in header <memory> class bad_weak_ptr; (since C++11) std::bad_weak_ptr is the type of the object thrown as exceptions by the constructors of std::shared_ptr that take std::weak_ptr as the argument, when the std::weak_ptr refers to an already deleted object. Inheritance diagram. Member functions (constructor) constructs the bad_weak_ptr object (public member function) Inherited from std::exception Member functions (destructor) [virtual]

Defined in header <cstdio> void perror( const char *s ); Prints a textual description of the error code currently stored in the system variable errno to stderr. The description is formed by concatenating the following components: the contents of the null-terminated byte string pointed to by s (unless s is a null pointer) ": " implementation-defined error message describing the error code stored in errno. This message is identical to the output of std::strerror(errno).

Defined in header <locale> public: dateorder date_order() const; (1) protected: virtual dateorder do_date_order() const; (2) 1) Public member function, calls the protected virtual member function do_date_order of the most derived class. 2) Returns a value of type std::time_base::dateorder, which describes the default date format used by this locale (expected by get_date() and produced by std::strftime() with format specifier '%x'). The valid values (inherited from s

Defined in header <thread> template< class Rep, class Period > void sleep_for( const std::chrono::duration<Rep, Period>& sleep_duration ); (since C++11) Blocks the execution of the current thread for at least the specified sleep_duration. A steady clock is used to measure the duration. This function may block for longer than sleep_duration due to scheduling or resource contention delays. Parameters sleep_duration - time duration to sleep Return

(since C++11) (member only of atomic<Integral> template specialization) T fetch_or( T arg, std::memory_order order = std::memory_order_seq_cst ); T fetch_or( T arg, std::memory_order order = std::memory_order_seq_cst ) volatile; Atomically replaces the current value with the result of bitwise OR of the value and arg. The operation is read-modify-write operation. Memory is affected according to the value of order. Parameters arg - the oth

(since C++11) void store( T desired, std::memory_order order = std::memory_order_seq_cst ); void store( T desired, std::memory_order order = std::memory_order_seq_cst ) volatile; Atomically replaces the current value with desired. Memory is affected according to the value of order. order must be one of std::memory_order_relaxed, std::memory_order_release or std::memory_order_seq_cst. Otherwise the behavior is undefined. Parameters desired - the value to store into the

Specifies that the type is POD (Plain Old Data) type. This means the type is compatible with the types used in the C programming language, can be manipulated using C library functions: it can be created with std::malloc, it can be copied with std::memmove, etc, and can be exchanged with C libraries directly, in its binary form. Note, that the standard doesn't define a named requirement or concept with this name. This is a type category defined by the core language. It is included here as concep

A Hash is a function object for which the output depends only on the input and has a very low probability of yielding the same output given different input values. Requirements The type T satisfies Hash if. The type T satisfies FunctionObject, CopyConstructible, Destructible, and Given. h, a value of type T or const T, whose argument type is Key k, a value of type convertible to Key or const Key u, an lvalue expression of type Key The following expressions must be valid and have t

The SharedMutex concept extends the Mutex concept to include shared lock ownership mode. Requirements Mutex Additionally, for object m of SharedMutex type supports another mode of ownership: shared. Multiple threads (or, more generally, execution agents) can simulataneously own this mutex in shared mode, but no thread may obtain shared ownership if there is a thread that owns it in exclusive mode and no thread may obtain exclusive ownership if there is a thread that owns it in shared mode

The SharedTimedMutex concept extends the TimedMutex concept to include shared lock ownership mode. Requirements TimedMutex SharedMutex Additionally, for object m of SharedTimedMutex type supports timed shared operations: The expression m.try_lock_shared_for(duration) has the following properties Behaves as an atomic operation. Attempts to obtain shared ownership of the mutex within the duration specified by duration. If duration is less or equal duration.zero(), attempts to obtain