Defined in header <algorithm> template< class ForwardIt, class T > std::pair<ForwardIt,ForwardIt> equal_range( ForwardIt first, ForwardIt last, const T& value ); (1) template< class ForwardIt, class T, class Compare > std::pair<ForwardIt,ForwardIt> equal_range( ForwardIt first, ForwardIt last, const T& value, Compare comp ); (2) Returns a range containing all elements equivalent to value in th

Defined in header <algorithm> template< class InputIt1, class InputIt2 > bool equal( InputIt1 first1, InputIt1 last1, InputIt2 first2 ); (1) template< class InputIt1, class InputIt2, class BinaryPredicate > bool equal( InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicate p ); (2) template< class InputIt1, class InputIt2 > bool equal( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2 );

Defined in header <ostream> template< class CharT, class Traits > std::basic_ostream<CharT, Traits>& ends( std::basic_ostream<CharT, Traits>& os ); Inserts a null character into the output sequence os as if by calling os.put(CharT()). This is an output-only I/O manipulator, it may be called with an expression such as out << std::ends for any out of type std::basic_ostream. Notes This manipulator is typically used with std::ostrstream, when

Defined in header <ostream> template< class CharT, class Traits > std::basic_ostream<CharT, Traits>& endl( std::basic_ostream<CharT, Traits>& os ); Inserts a newline character into the output sequence os and flushes it as if by calling os.put(os.widen('\n')) followed by os.flush(). This is an output-only I/O manipulator, it may be called with an expression such as out << std::endl for any out of type std::basic_ostream. Notes This manipula

template< class T > /*unspecified1*/ end( valarray<T>& v ); (1) (since C++11) template< class T > /*unspecified2*/ end( const valarray<T>& v ); (2) (since C++11) The overload of std::end for valarray returns an iterator of unspecified type referring to the one past the last element in the numeric array. 1) The return type meets the requirements of mutable RandomAccessIterator. 2) The return type meets the requirements of constant RandomAccessIte

template< class E > const E* end( initializer_list<E> il ); (since C++11) template< class E > constexpr const E* end( initializer_list<E> il ); (since C++11) (until C++14) The overload of std::end for initializer_list returns a pointer to one past the last element of il. Parameters il - an initializer_list Return value il.end(). Exceptions noexcept specification: noexcept Example #include <iostream> int main() { // ran

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

shared_ptr<T> shared_from_this(); (1) shared_ptr<T const> shared_from_this() const; (2) Returns a std::shared_ptr<T> that shares ownership of *this with all existing std::shared_ptr that refer to *this. Notes Before calling shared_from_this, there should be at least one std::shared_ptr p that owns *this. Return value std::shared_ptr<T> that shares ownership of *this with pre-existing std::shared_ptrs. Example #include <iostream> #include &l

constexpr enable_shared_from_this(); (1) (since C++11) enable_shared_from_this( const enable_shared_from_this<T>&obj ); (2) (since C++11) Constructs new enable_shared_from_this object. Parameters obj - an enable_shared_from_this to copy Exceptions noexcept specification: noexcept Example #include <memory> struct Foo : public std::enable_shared_from_this<Foo> { Foo() {} // implicitly calls enable_shared_from_this constructor std

Defined in header <memory> template< class T > class enable_shared_from_this; (since C++11) std::enable_shared_from_this allows an object t that is currently managed by a std::shared_ptr named pt to safely generate additional std::shared_ptr instances pt1, pt2, ... that all share ownership of t with pt. Inheriting from std::enable_shared_from_this<T> provides the type T with a member function shared_from_this. If an object t of type T is managed by a std::shared