Defined in header <locale> template< class CharT > class ctype; Class ctype encapsulates character classification features. All stream input operations performed through std::basic_istream<charT> use the std::ctype<charT> of the locale imbued in the stream to identify whitespace characters for input tokenization. Stream output operations apply std::ctype<charT>::widen() to narrow-character arguments prior to output. Inheritance diagram. Two sta

basic_string& append( size_type count, CharT ch ); (1) basic_string& append( const basic_string& str ); (2) (3) basic_string& append( const basic_string& str, size_type pos, size_type count ); (until C++14) basic_string& append( const basic_string& str, size_type pos, size_type count = npos); (since C++14) basic_string& append( const CharT* s,

Defined in header <regex> typedef /*unspecified*/ syntax_option_type; constexpr syntax_option_type icase = /*unspecified*/; constexpr syntax_option_type nosubs = /*unspecified*/; constexpr syntax_option_type optimize = /*unspecified*/; constexpr syntax_option_type collate = /*unspecified*/; constexpr syntax_option_type ECMAScript = /*unspecified*/; constexpr syntax_option_type basic = /*unspecified*/; constexpr syntax_option_type extended = /*unspecified*/; constexpr syntax_option

reference front(); (since {std}) const_reference front() const; (since {std}) Returns a reference to the first element in the container. Calling front on an empty container is undefined. Parameters (none). Return value reference to the first element. Complexity Constant. Notes For a container c, the expression c.front() is equivalent to *c.begin(). Example The following code uses front to display the first element of a std::dynarray<char>: #include <dynarr

void unsetf( fmtflags flags ); Unsets the formatting flags identified by flags. Parameters flags - formatting flags to unset. It can be a combination of the following constants: Constant Explanation dec use decimal base for integer I/O: see std::dec oct use octal base for integer I/O: see std::oct hex use hexadecimal base for integer I/O: see std::hex basefield dec|oct|hex|0. Useful for masking operations left left adjustment (adds fill characters to the r

Defined in header <mutex> template< class Mutex > class unique_lock; (since C++11) The class unique_lock is a general-purpose mutex ownership wrapper allowing deferred locking, time-constrained attempts at locking, recursive locking, transfer of lock ownership, and use with condition variables. The class unique_lock is movable, but not copyable -- it meets the requirements of MoveConstructible and MoveAssignable but not of CopyConstructible or CopyAssignable. The clas

virtual const char* what() const; Returns the explanatory string. Parameters (none). Return value Pointer to a null-terminated string with explanatory information. The pointer is guaranteed to be valid at least until the exception object from which it is obtained is destroyed, or until a non-const member function on the exception object is called. Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11)

Defined in header <type_traits> template< class T > struct is_default_constructible; (1) (since C++11) template< class T > struct is_trivially_default_constructible; (2) (since C++11) template< class T > struct is_nothrow_default_constructible; (3) (since C++11) 1) If std::is_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false. 2) If std::is_trivially_constructible<T>::value is

Defined in header <locale> public: iter_type get_monthname( iter_type beg, iter_type end, std::ios_base& str, std::ios_base::iostate& err, std::tm* t) const; (1) protected: virtual iter_type do_get_monthname( iter_type beg, iter_type end, std::ios_base& str, std::ios_base::iostate& err, std::tm* t) const; (2) 1) public member function, calls the protected virtual member function do_get_month

template< class T, class Alloc > bool operator==( const deque<T,Alloc>& lhs, const deque<T,Alloc>& rhs ); (1) template< class T, class Alloc > bool operator!=( const deque<T,Alloc>& lhs, const deque<T,Alloc>& rhs ); (2) template< class T, class Alloc > bool operator<( const deque<T,Alloc>& lhs, const deque<T,Alloc>& rhs ); (3) template< class T