Defined in header <mutex> struct defer_lock_t { }; (since C++11) struct try_to_lock_t { }; (since C++11) struct adopt_lock_t { }; (since C++11) std::defer_lock_t, std::try_to_lock_t and std::adopt_lock_t are empty struct tag types used to specify locking strategy for std::lock_guard, std::unique_lock and std::shared_lock. Type Effect(s) defer_lock_t do not acquire ownership of the mutex try_to_lock_t try to acquire ownership of the mutex without block

reference back(); const_reference back() const; Returns reference to the last element in the container. Calling back on an empty container is undefined. Parameters (none). Return value Reference to the last element. Complexity Constant. Notes For a container c, the expression return c.back(); is equivalent to { auto tmp = c.end(); --tmp; return *tmp; } Example The following code uses back to display the last element of a std::deque<char>: #include <deque&g

Defined in header <cfenv> int fetestexcept( int excepts ); (since C++11) Determines which of the specified subset of the floating point exceptions are currently set. The argument excepts is a bitwise OR of the floating point exception macros. Parameters excepts - bitmask listing the exception flags to test Return value Bitwise OR of the floating-point exception macros that are both included in excepts and correspond to floating-point exceptions currently set.

Defined in header <cfenv> int feupdateenv( const std::fenv_t* envp ) (since C++11) First, remembers the currently raised floating-point exceptions, then restores the floating-point environment from the object pointed to by envp (similar to std::fesetenv), then raises the floating-point exceptions that were saved. This function may be used to end the non-stop mode established by an earlier call to std::feholdexcept. Parameters envp - pointer to the object of type std

bool operator==( const error_category& rhs ) const; (1) (since C++11) bool operator!=( const error_category& rhs ) const; (2) (since C++11) bool operator<( const error_category& rhs ) const; (3) (since C++11) Compares to another error category. 1) Checks whether *this and rhs refer to the same object. 2) Checks whether *this and rhs do not refer to the same object. 3) Orders *this and rhs by the order of this and &rhs. Equivalent to std::less<const e

Defined in header <ctime> char* ctime( const std::time_t* time ); Converts given time since epoch to a calendar local time and then to a textual representation, as if by calling std::asctime(std::localtime(time)). The resulting string has the following format: Www Mmm dd hh:mm:ss yyyy Www - the day of the week (one of Mon, Tue, Wed, Thu, Fri, Sat, Sun). Mmm - the month (one of Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec). dd - the day of the month hh -

Defined in header <stdexcept> class length_error; Defines a type of object to be thrown as exception. It reports errors that are consequence of attempt to exceed implementation defined length limits for some object. This exception is thrown by member functions of std::basic_string and std::vector::reserve. Inheritance diagram. Member functions (constructor) constructs the exception object (public member function) std::length_error::length_error explici

template <class M> pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); (1) (since C++17) template <class M> pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); (2) (since C++17) template <class M> iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); (3) (since C++17) template <class M> iterator insert_or_assign(const_iterator hint, key_type&& k,

Defined in header <memory> template< class T > T* addressof(T& arg); (since C++11) Obtains the actual address of the object or function arg, even in presence of overloaded operator& Parameters arg - lvalue object or function Return value Pointer to arg. Exceptions noexcept specification: noexcept Possible implementation template< class T > T* addressof(T& arg) { return reinterpret_cast<T*>( &const_

template< class T > /*unspecified1*/ end( valarray<T>& v ); (1) (since C++11) template< class T > /*unspecified2*/ end( const valarray<T>& v ); (2) (since C++11) The overload of std::end for valarray returns an iterator of unspecified type referring to the one past the last element in the numeric array. 1) The return type meets the requirements of mutable RandomAccessIterator. 2) The return type meets the requirements of constant RandomAccessIte