Defined in header <cuchar> std::size_t mbrtoc32( char32_t* pc32, const char* s, std::size_t n, std::mbstate_t* ps ); (since C++11) Converts a narrow multibyte character to its UTF-32 character representation. If s is not a null pointer, inspects at most n bytes of the multibyte character string, beginning with the byte pointed to by s to determine the number of bytes necessary to complete the next multibyte c

This header is part of the error handling library. Classes error_category (C++11) base class for error categories (class) generic_category (C++11) identifies the generic error category (function) system_category (C++11) identifies the operating system error category (function) error_condition (C++11) holds a portable error code (class) errc (C++11) the std::error_condition enumeration listing all standard <cerrno> macro constants (class) error_code

Introduces a name that is defined elsewhere into the declarative region where this using-declaration appears. using typename(optional) nested-name-specifier unqualified-id ; nested-name-specifier - a sequence of names and scope resolution operators ::, ending with a scope resolution operator. A single :: refers to the global namespace. unqualified-id - an id-expression typename - the keyword typename may be used as necessary to resolve dependent names, when the using-de

Defined in header <locale> public: iter_type get(iter_type beg, iter_type end, std::ios_base& str, std::ios_base::iostate& err, std::tm* t, const char_type* fmtbeg, const char_type* fmtend) const; (1) (since C++11) protected: virtual iter_type do_get(iter_type neg, iter_type end, std::ios_base& str, std::ios_base::iostate& err, std::tm *t, char format, char modifier) const; (2)

basic_istream& ignore( std::streamsize count = 1, int_type delim = Traits::eof() ); Extracts and discards characters from the input stream until and including delim. ignore behaves as an UnformattedInputFunction. After constructing and checking the sentry object, it extracts characters from the stream and discards them until any one of the following conditions occurs: count characters were extracted. This test is disabled in the special case when count equals std::numeric_limits<

template <class... Args> iterator emplace_hint( const_iterator hint, Args&&... args ); (since C++11) Inserts a new element into the container as close as possible to the position just before hint. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with exactly the same arguments as supplied to the function, forwarded with std::forward<Args>(args).... No iterators or references are invalidated.

Defined in header <type_traits> template< class T > struct is_arithmetic; (since C++11) If T is an arithmetic type (that is, an integral type or a floating-point type), provides the member constant value equal true. For any other type, value is false. Template parameters T - a type to check Helper variable template template< class T > constexpr bool is_arithmetic_v = is_arithmetic<T>::value; (since C++17) Inherited from std::inte

Defined in header <algorithm> template< class RandomIt > void random_shuffle( RandomIt first, RandomIt last ); (1) (until C++17)(deprecated in C++14) (2) template< class RandomIt, class RandomFunc > void random_shuffle( RandomIt first, RandomIt last, RandomFunc& r ); (until C++11) template< class RandomIt, class RandomFunc > void random_shuffle( RandomIt first, RandomIt last, RandomFunc&& r ); (since C++11) (until C++17)(deprecated in

Defined in header <array> template< class T, std::size_t N > struct array; (since C++11) std::array is a container that encapsulates fixed size arrays. This container is an aggregate type with the same semantics as a struct holding a C-style array T[N] as its only non-static data member. Unlike a C-style array, it doesn't decay to T* automatically. As an aggregate type, it can be initialized with aggregate-initialization given at most N initializers that ar

Defined in header <utility> template< class T > typename std::remove_reference<T>::type&& move( T&& t ); (since C++11) (until C++14) template< class T > constexpr typename std::remove_reference<T>::type&& move( T&& t ); (since C++14) std::move is used to indicate that an object t may be "moved from", i.e. allowing the efficient transfer of resources from t to another object. In particular, std::move produces an x