Defined in header <cfenv> int feclearexcept( int excepts ); (since C++11) Attempts to clear the floating-point exceptions that are listed in the bitmask argument excepts, which is a bitwise OR of the floating point exception macros. Parameters excepts - bitmask listing the exception flags to clear Return value ​0​ if all indicated exceptions were successfully cleared or if excepts is zero. Returns a non-zero value on error. Example #include <iostream&g

Defined in header <future> enum class future_status { ready, timeout, deferred }; (since C++11) Specifies state of a future as returned by wait_for and wait_until functions of std::future and std::shared_future. Constant Explanation deferred the shared state contains a deferred function, so the result will be computed only when explicitly requested ready the shared state is ready timeout the shared state did not become ready before specified timeo

Defined in header <functional> template<> class logical_or<void>; (since C++14) std::logical_or<> is a specialization of std::logical_or with parameter and return type deduced. Member types Member type Definition is_transparent /* unspecified */ Member functions operator() applies operator to lhs and rhs (public member function) std::logical_or<>::operator() template< class T, class U> constexpr auto operator()( T

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

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 mutex. Parameters (none). Return value (none). Exceptions (none). Notes unlock_shared() is usually not called directly: std::shar

native_handle_type native_handle(); (since C++11) Accesses the native handle of *this. The meaning and the type of the result of this function is implementation-defined. On a POSIX system, this may be a value of type pthread_cond_t*. On a Windows system, this may be a PCONDITION_VARIABLE. Parameters (none). Return value The native handle of this condition variable. See also native_handle returns the underlying implementation-defined thread handle (public member function of

T* data(); (since C++11) const T* data() const; (since C++11) Returns pointer to the underlying array serving as element storage. The pointer is such that range [data(); data() + size()) is always a valid range, even if the container is empty. Parameters (none). Return value Pointer to the underlying element storage. For non-empty containers, returns &front(). Complexity Constant. Exceptions noexcept specification: noexcept See also front access the first

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 -

Specifies that a type is trivial type. 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 concept only for consistency. Requirements TriviallyCopyable Trivial default constructor See also is_trivial (C++11) checks if a type is trivial (class template)

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,