Defined in header <locale> class ctype_base; The class std::ctype_base lists the character classification categories which are inherited by the std::ctype facets. Member types mask unspecified BitmaskType (enumeration, integer type, or bitset) (typedef) Member constants space [static] the value of mask identifying whitespace character classification (public static member constant) print [static] the value of mask identifying printable character class

Defined in header <cmath> float acosh( float arg ); (1) (since C++11) double acosh( double arg ); (2) (since C++11) long double acosh( long double arg ); (3) (since C++11) double acosh( Integral arg ); (4) (since C++11) Computes the inverse hyperbolic cosine of 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 - value of a

Defined in header <istream> template< class CharT, class Traits = std::char_traits<CharT> > class basic_istream : virtual public std::basic_ios<CharT, Traits> The class template basic_istream provides support for high level input operations on character streams. The supported operations include formatted input (e.g. integer values or whitespace-separated characters and characters strings) and unformatted input (e.g. raw characters and character a

Defined in header <cuchar> std::size_t c16rtomb( char* s, char16_t c16, std::mbstate_t* ps ); (since C++11) Converts a UCS-2 code point to narrow multibyte character. If s is not a null pointer, the function determines the number of bytes necessary to store the multibyte character representation of c16 (including any shift sequences), and stores the multibyte character representation in the character array whose first element is pointed to by s. At most MB_CUR_MAX bytes can

template< class... Args > std::pair<iterator,bool> emplace( Args&&... args ); (since C++11) Inserts a new element into the container by constructing it in-place with the given args if there is no element with the key in the container. Careful use of emplace allows the new element to be constructed while avoiding unnecessary copy or move operations. The constructor of the new element is called with exactly the same arguments as supplied to emplace, forwarded via std::

protected: virtual pos_type seekpos(pos_type sp, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out ); Repositions std::basic_streambuf::gptr and/or std::basic_streambuf::pptr, if possible, to the position indicated by sp. Effectively executes seekoff(off_type(sp), std::ios_base::beg, which). Parameters sp - stream position, such as one obtained by seekoff() or seekpos() which - defines whether the input sequences, the output se

Defined in header <iterator> template< class C > auto begin( C& c ) -> decltype(c.begin()); (1) (since C++11) template< class C > auto begin( const C& c ) -> decltype(c.begin()); (1) (since C++11) (2) template< class T, std::size_t N > T* begin( T (&array)[N] ); (since C++11) (until C++14) template< class T, std::size_t N > constexpr T* begin( T (&array)[N] ); (since C++14) template< class C > constex

void swap( thread &lhs, thread &rhs ); (since C++11) Overloads the std::swap algorithm for std::thread. Exchanges the state of lhs with that of rhs. Effectively calls lhs.swap(rhs). Parameters lhs, rhs - threads whose states to swap Return value (none). Exceptions noexcept specification: noexcept Example #include <iostream> #include <thread> #include <chrono> void foo() { std::this_thread::sleep_for(std::chrono::seconds(1)); } vo

Defined in header <cstdlib> std::size_t wcstombs( char* dst, const wchar_t* src, std::size_t len); Converts a sequence of wide characters from the array whose first element is pointed to by src to its narrow multibyte representation that begins in the initial shift state. Converted characters are stored in the successive elements of the char array pointed to by dst. No more than len bytes are written to the destination array. Each character is converted as if by a call to s

Manipulators are helper functions that make it possible to control input/output streams using operator<< or operator>>. The manipulators that are invoked without arguments (e.g. std::cout << std::boolalpha; or std::cin >> std::hex;) are implemented as functions that take a reference to a stream as their only argument. The special overloads of basic_ostream::operator<< and basic_istream::operator>> accept pointers to these functions. The manipulators that are