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

A copy assignment operator of class T is a non-template non-static member function with the name operator= that takes exactly one parameter of type T, T&, const T&, volatile T&, or const volatile T&. For a type to be CopyAssignable, it must have a public copy assignment operator. Syntax class_name & class_name :: operator= ( class_name ) (1) class_name & class_name :: operator= ( const class_name & ) (2) class_name & class_name :: operator= ( cons

iterator erase( const_iterator pos ); (1) (since C++11) iterator erase( const_iterator first, const_iterator last ); (2) (since C++11) size_type erase( const key_type& key ); (3) (since C++11) Removes specified elements from the container. 1) Removes the element at pos. 2) Removes the elements in the range [first; last), which must be a valid range in *this. 3) Removes the element (if one exists) with the key equivalent to key. References and iterators to the erased e

Defined in header <cmath> bool isnan( float arg ); (1) (since C++11) bool isnan( double arg ); (2) (since C++11) bool isnan( long double arg ); (3) (since C++11) bool isnan( Integral arg ); (4) (since C++11) 1-3) Determines if the given floating point number arg is a not-a-number (NaN) value. 4) A set of overloads or a function template accepting the from argument of any integral type. Equivalent to (2) (the argument is cast to double). Parameters a

Each name that appears in a C++ program is only valid in some possibly discontiguous portion of the source code called its scope. Within a scope, unqualified name lookup can be used to associate the name with its declaration. Block scope The potential scope of a variable introduced by a declaration in a block (compound statement) begins at the point of declaration and ends at the end of the block. Actual scope is the same as potential scope unless there is a nested block with a declaration t

time_point& operator+=( const duration& d ); (1) (since C++11) time_point& operator-=( const duration& d ); (2) (since C++11) Modifies the time point by the given duration. 1) Applies the offset d to pt. Effectively, d is added to the internally stored duration d_ as d_ += d. 2) Applies the offset d to pt in negative direction. Effectively, d is subtracted from internally stored duration d_ as d_ -= d. Parameters d - a time offset to apply Return val

Converts between types using a combination of implicit and user-defined conversions. Syntax static_cast < new_type > ( expression ) Returns a value of type new_type. Explanation Only the following conversions can be done with static_cast, except when such conversions would cast away constness or volatility. 1) If a temporary object of type new_type can be declared and initialized with expression, as by new_type Temp(expression);, which may involve implicit conversions, a ca

Defined in header <string> float stof( const std::string& str, std::size_t* pos = 0 ); float stof( const std::wstring& str, std::size_t* pos = 0 ); (1) (since C++11) double stod( const std::string& str, std::size_t* pos = 0 ); double stod( const std::wstring& str, std::size_t* pos = 0 ); (2) (since C++11) long double stold( const std::string& str, std::size_t* pos = 0 ); long double stold( const std::wstring& str, std::size

static T round_error(); (until C++11) static constexpr T round_error(); (since C++11) Returns the largest possible rounding error in ULPs (units in the last place) as defined by ISO 10967, which can vary from 0.5 (rounding to the nearest digit) to 1.0 (rounding to zero or to infinity). It is only meaningful if std::numeric_limits<T>::is_integer == false. Return value T std::numeric_limits<T>::round_error() /* non-specialized */ T(); bool false char ​0

unique_lock(); (1) (since C++11) unique_lock( unique_lock&& other ); (2) (since C++11) explicit unique_lock( mutex_type& m ); (3) (since C++11) unique_lock( mutex_type& m, std::defer_lock_t t ); (4) (since C++11) unique_lock( mutex_type& m, std::try_to_lock_t t ); (5) (since C++11) unique_lock( mutex_type& m, std::adopt_lock_t t ); (6) (since C++11) template< class Rep, class Period > unique_lock( mutex_type& m,