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( const C& c ) -> decltype(std::end(c)); | (3) | (since C++14) |
Returns an iterator to the end (i.e. the element after the last element) of the given container c
or array array
. These templates rely on C::end()
having a reasonable implementation.
c.end()
, which is typically an iterator one past the end of the sequence represented by c
. If C
is a standard Container
, this returns a C::iterator
when c
is not const-qualified, and a C::const_iterator
otherwise.array
.std::end(c)
, with c
always treated as const-qualified. If C
is a standard Container
, this always returns a C::const_iterator
.Parameters
c | - | a container with an end method |
array | - | an array of arbitrary type |
Return value
An iterator to the end of c
or array
. Note that the end of a container or array is defined as the element following the last valid element.
Exceptions
noexcept
specification: noexcept(noexcept(std::end(c)))
Notes
In addition to being included in <iterator>
, std::end
is guaranteed to become available if any of the following headers are included: <array>
, <deque>
, <forward_list>
, <list>
, <map>
, <regex>
, <set>
, <string>
, <unordered_map>
, <unordered_set>
, and <vector>
.
User-defined overloads
Custom overloads of std::end
may be provided for classes that do not expose a suitable end()
member function, yet can be iterated. The following overloads are already provided by the standard library:
(C++11) | specializes std::end (function template) |
(C++11) | specializes std::end (function template) |
Similar to the use of swap
(described in Swappable
), typical use of the end
function in generic context is an equivalent of using std::end; end(arg);
, which lets both the ADL-selected overloads for user-defined types and the standard library function templates to appear in the same overload set.
template<typename Container, typename Function> void for_each(Container&& cont, Function f) { using std::begin; auto it = begin(cont); using std::end; auto end_it = end(cont); while (it != end_it) { f(*it); ++it; } }
Example
#include <iostream> #include <vector> #include <iterator> #include <algorithm> int main() { std::vector<int> v = { 3, 1, 4 }; if (std::find(std::begin(v), std::end(v), 5) != std::end(v)) { std::cout << "found a 5 in vector v!\n"; } int a[] = { 5, 10, 15 }; if (std::find(std::begin(a), std::end(a), 5) != std::end(a)) { std::cout << "found a 5 in array a!\n"; } }
Output:
found a 5 in array a!
See also
(C++11)(C++14) | returns an iterator to the beginning of a container or array (function) |
Please login to continue.