Defined in header <algorithm> template< class InputIt, class RandomIt > RandomIt partial_sort_copy( InputIt first, InputIt last, RandomIt d_first, RandomIt d_last ); (1) template< class InputIt, class RandomIt, class Compare > RandomIt partial_sort_copy( InputIt first, InputIt last, RandomIt d_first, RandomIt d_last, Compare comp ); (2) Sorts some of the elements in the ran

reference at( size_type pos ); (since {std}) const_reference at( size_type pos ) const; Returns a reference to the element at specified location pos, with bounds checking. If pos not within the range of the container, an exception of type std::out_of_range is thrown. Parameters pos - position of the element to return Return value Reference to the requested element. Exceptions std::out_of_range if !(pos < size()). Complexity Constant. See also oper

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 (i.e. std::pair<const Key, T>) is called with exactly the same arguments as sup

Defined in header <algorithm> template< class ForwardIt, class T > bool binary_search( ForwardIt first, ForwardIt last, const T& value ); (1) template< class ForwardIt, class T, class Compare > bool binary_search( ForwardIt first, ForwardIt last, const T& value, Compare comp ); (2) Checks if an element equivalent to value appears within the range [first, last). For std::binary_search to succeed, the range [first, last) must be at least partially or

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

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

Rule of three If a class requires a user-defined destructor, a user-defined copy constructor, or a user-defined copy assignment operator, it almost certainly requires all three. Because C++ copies and copy-assigns objects of user-defined types in various situations (passing/returning by value, manipulating a container, etc), these special member functions will be called, if accessible, and if they are not user-defined, they are implicitly-defined by the compiler. The implicitly-defined speci

Defined in header <cmath> float tgamma( float arg ); (1) (since C++11) double tgamma( double arg ); (2) (since C++11) long double tgamma( long double arg ); (3) (since C++11) double tgamma( Integral arg ); (4) (since C++11) 1-3) Computes the gamma function 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 f

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