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

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

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::

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

Defined in header <scoped_allocator> template< class OuterAlloc, class... InnerAlloc > class scoped_allocator_adaptor : public OuterAlloc; (since C++11) The std::scoped_allocator_adaptor class template is an allocator which can be used with multilevel containers (vector of sets of lists of tuples of maps, etc). It is instantiated with one outer allocator type OuterAlloc and zero or more inner allocator types InnerAlloc.... A container constructed directly with a scope

The random number library provides classes that generate random and pseudo-random numbers. These classes include: Random number engines (both pseudo-random number generators, which generate integer sequences with a uniform distribution, and true random number generators if available) Random number distributions (e.g. uniform, normal, or poisson distributions) which convert the output of random number engines into various statistical distributions Engines and distributions are designed to

Defined in header <complex> template< class T > complex<T> pow( const complex<T>& x, const complex<T>& y); template< class T > complex<T> pow( const complex<T>& x, const T& y); template< class T > complex<T> pow( const T& x, const complex<T>& y); template< class T, class U > complex</*Promoted*/> pow( const complex<T>& x, const complex<U>& y);

Defined in header <mutex> template< class Lockable1, class Lockable2, class... LockableN > void lock( Lockable1& lock1, Lockable2& lock2, LockableN&... lockn ); (since C++11) Locks the given Lockable objects lock1, lock2, ..., lockn using a deadlock avoidance algorithm to avoid deadlock. The objects are locked by an unspecified series of calls to lock, try_lock, unlock. If a call to lock or unlock results in an exception, unlock is called for any locked ob

Defined in header <algorithm> template< class RandomIt > void partial_sort( RandomIt first, RandomIt middle, RandomIt last ); (1) template< class RandomIt, class Compare > void partial_sort( RandomIt first, RandomIt middle, RandomIt last, Compare comp ); (2) Rearranges elements such that the range [first, middle) contains the sorted middle - first smallest elements in the range [first, last). The order of equal elements is not guaranteed to be preserved. T

Associates one or more exception handlers (catch-clauses) with a compound statement. Syntax try compound-statement handler-sequence where handler-sequence is a sequence of one or more handlers, which have the following syntax: catch ( attr(optional) type-specifier-seq declarator ) compound-statement (1) catch ( attr(optional) type-specifier-seq abstract-declarator(optional) ) compound-statement (2) catch ( ... ) compound-statement (3) compound-statement - bra