Defined in header <thread> class thread; (since C++11) The class thread represents a single thread of execution. Threads allow multiple pieces of code to run asynchronously and simultaneously. std::thread objects may also be in the state that does not represent any thread (it gets into that state after default construction, a move from, detach, or join), and a thread of execution may be not associated with any thread objects (it gets into that state after detach). No two st

Defined in header <ostream> template< class CharT, class Traits > std::basic_ostream<CharT, Traits>& endl( std::basic_ostream<CharT, Traits>& os ); Inserts a newline character into the output sequence os and flushes it as if by calling os.put(os.widen('\n')) followed by os.flush(). This is an output-only I/O manipulator, it may be called with an expression such as out << std::endl for any out of type std::basic_ostream. Notes This manipula

Defined in header <memory> template< class T, class... Args > unique_ptr<T> make_unique( Args&&... args ); (1) (since C++14)(only for non-array types) template< class T > unique_ptr<T> make_unique( std::size_t size ); (2) (since C++14)(only for array types with unknown bound) template< class T, class... Args > /* unspecified */ make_unique( Args&&... args ) = delete; (3) (since C++14)(only for array types with known bou

static const std::float_round_style round_style (until C++11) static constexpr std::float_round_style round_style (since C++11) The value of std::numeric_limits<T>::round_style identifies the rounding style used by the floating-point type T whenever a value that is not one of the exactly repesentable values of T is stored in an object of that type. Standard specializations T value of std::numeric_limits<T>::round_style /* non-specialized */ std::round_toward_

static constexpr T lowest() (since C++11) Returns the lowest finite value representable by the numeric type T, that is, a finite value x such that there is no other finite value y where y < x. This is different from std::numeric_limits<T>::min() for floating-point types. Only meaningful for bounded types. Return value T std::numeric_limits<T>::lowest() /* non-specialized */ T(); bool false char CHAR_MIN signed char SCHAR_MIN unsigned char ​0​ w

Defined in header <cmath> float floor( float arg ); (1) double floor( double arg ); (2) long double floor( long double arg ); (3) double floor( Integral arg ); (4) (since C++11) 1-3) Computes the largest integer value not greater than arg. 4) A set of overloads or a function template accepting an argument of any integral type. Equivalent to 2) (the argument is cast to double). Parameters arg - floating point value Return val

Defined in header <codecvt> template< class Elem, unsigned long Maxcode = 0x10ffff, std::codecvt_mode Mode = (std::codecvt_mode)0 > class codecvt_utf8 : public std::codecvt<Elem, char, std::mbstate_t>; std::codecvt_utf8 is a std::codecvt facet which encapsulates conversion between a UTF-8 encoded byte string and UCS2 or UCS4 character string (depending on the type of Elem). This codecvt facet can be used to read and write UTF-8 files, both text and

Defined in header <locale> template< class CharT, class OutputIt = std::ostreambuf_iterator<CharT> > class time_put; Class template std::time_put encapsulates date and time formatting rules. The I/O manipulator std::put_time uses the std::time_put facet of the I/O stream's locale to generate text representation of an std::tm object. Inheritance diagram. Type requirements - OutputIt must meet the requirements of OutputIterator. Specializ

void reset(); (since C++11) Resets the internal state of the distribution object. After a call to this function, the next call to operator() on the distribution object will not be dependent on previous calls to operator(). Parameters (none). Return value (none). Complexity Constant.

(1) explicit map( const Compare& comp = Compare(), const Allocator& alloc = Allocator() ); (until C++14) map() : map( Compare() ) {} explicit map( const Compare& comp, const Allocator& alloc = Allocator() ); (since C++14) explicit map( const Allocator& alloc ); (1) (since C++11) (2) template< class InputIterator > map( InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocat