std::end,std::cend

From cppreference.com

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros(C++20)
Language support library
Concepts library(C++20)
Diagnostics library
Memory management library
Metaprogramming library(C++11)
General utilities library
Containers library
Iterators library
Ranges library(C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library(C++17)
Concurrency support library(C++11)
Execution control library(C++26)
Technical specifications
Symbols index
External libraries

[edit]

Iterator library

Iterator concepts

indirectly_readable (C++20)
indirectly_writable (C++20)
weakly_incrementable (C++20)
incrementable (C++20)
is-integer-like is-signed-integer-like (C++20)(C++20)

sentinel_for (C++20)
sized_sentinel_for (C++20)
input_iterator (C++20)
output_iterator (C++20)
input_or_output_iterator (C++20)

forward_iterator (C++20)
bidirectional_iterator (C++20)
random_access_iterator (C++20)
contiguous_iterator (C++20)

Iterator primitives

input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tagcontiguous_iterator_tag

(C++20)

iter_value_titer_difference_titer_reference_titer_const_reference_titer_rvalue_reference_titer_common_reference_t

(C++20)(C++20)(C++20)(C++23)(C++20)(C++20)

iterator (deprecated in C++17)
iterator_traits
incrementable_traits (C++20)
indirectly_readable_traits (C++20)

Algorithm concepts and utilities

Indirect callable concepts

indirectly_unary_invocableindirectly_regular_unary_invocable

(C++20)(C++20)

indirect_unary_predicate (C++20)
indirect_binary_predicate (C++20)

indirect_equivalence_relation (C++20)
indirect_strict_weak_order (C++20)

Common algorithm requirements

indirectly_movable (C++20)
indirectly_movable_storable (C++20)
indirectly_copyable (C++20)

indirectly_copyable_storable (C++20)
indirectly_swappable (C++20)
indirectly_comparable (C++20)

permutable (C++20)
mergeable (C++20)
sortable (C++20)

(C++20)

(C++20)

(C++26)

reverse_iterator
make_reverse_iterator (C++14)
move_iterator (C++11)
make_move_iterator (C++11)
default_sentinel_tdefault_sentinel (C++20)(C++20)
unreachable_sentinel_tunreachable_sentinel (C++20)(C++20)

front_insert_iterator
back_insert_iterator
inserter
insert_iterator
front_inserter
back_inserter
move_sentinel (C++20)

common_iterator (C++20)
counted_iterator (C++20)
basic_const_iterator (C++23)
const_iterator (C++23)
const_sentinel (C++23)
make_const_iterator (C++23)
make_const_sentinel (C++23)

Stream iterators

istream_iterator
ostream_iterator

istreambuf_iterator
ostreambuf_iterator

Iterator customization points
ranges::iter_move (C++20)
ranges::iter_swap (C++20)

Iterator operations

advance
distance
prev (C++11)
next (C++11)

ranges::advance (C++20)
ranges::distance (C++20)
ranges::prev (C++20)
ranges::next (C++20)

Range access

begincbegin (C++11)(C++14)
rbegincrbegin (C++14)(C++14)

endcend (C++11)(C++14)
rendcrend (C++14)(C++14)

sizessize (C++17)(C++20)
empty (C++17)
data (C++17)

[edit]

Defined in header`<array>`
Defined in header`<deque>`
Defined in header`<flat_map>`
Defined in header`<flat_set>`
Defined in header`<forward_list>`
Defined in header`<inplace_vector>`
Defined in header`<iterator>`
Defined in header`<list>`
Defined in header`<map>`
Defined in header`<regex>`
Defined in header`<set>`
Defined in header`<span>`
Defined in header`<string>`
Defined in header`<string_view>`
Defined in header`<unordered_map>`
Defined in header`<unordered_set>`
Defined in header`<vector>`
template<class C> auto end( C& c)-> decltype(c.end());	(1)	(since C++11) (constexpr since C++17)
template<class C> auto end(const C& c)-> decltype(c.end());	(2)	(since C++11) (constexpr since C++17)
template<class T,std::size_t N> T* end( T(&array)[N]);	(3)	(since C++11) (noexcept since C++14) (constexpr since C++14)
template<class C> constexprauto cend(const C& c)noexcept(/* see below */) -> decltype(std::end(c));	(4)	(since C++14)

Returns an iterator to the end (i.e. the element after the last element) of the given range.

1,2) Returnsc.end(), which is typically an iterator one past the end of the sequence represented byc.

1) IfC is a standardContainer, returns aC::iterator object.

2) IfC is a standardContainer, returns aC::const_iterator object.

3) Returns a pointer to the end ofarray.

4) Returnsstd::end(c), withc always treated as const-qualified.

IfC is a standardContainer, returns aC::const_iterator object.

[edit]Parameters

c	-	a container or view with an`end` member function
array	-	an array of arbitrary type

[edit]Return value

1,2)c.end()

3)array+ N

4)c.end()

[edit]Exceptions

noexcept specification:

noexcept(noexcept(std::end(c)))

[edit]Overloads

Custom overloads ofend may be provided for classes and enumerations that do not expose a suitableend() member function, yet can be iterated. The following overloads are already provided by the standard library:

std::end(std::initializer_list) (C++11)	specializesstd::end (function template)[edit]
std::end(std::valarray) (C++11)	specializesstd::end (function template)[edit]
begin(std::filesystem::directory_iterator)end(std::filesystem::directory_iterator) (C++17)	range-based for loop support (function)[edit]
begin(std::filesystem::recursive_directory_iterator)end(std::filesystem::recursive_directory_iterator)	range-based for loop support (function)[edit]

Similar to the use ofswap (described inSwappable), typical use of theend function in generic context is an equivalent ofusing std::end; end(arg);, which lets both theADL-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){usingstd::begin;auto it= begin(cont);using std::end;auto end_it= end(cont); for(; it!= end_it;++it)        f(*it);}

Overloads ofend found byargument-dependent lookup can be used to customize the behavior ofstd::ranges::end,std::ranges::cend, and other customization pointer objects depending onstd::ranges::end.

(since C++20)

[edit]Notes

The non-array overloads exactly reflect the behavior ofC::end(). Their effects may be surprising if the member function does not have a reasonable implementation.

std::cend is introduced for unification of member and non-member range accesses. See alsoLWG issue 2128.

IfC is a shallow-const view,std::cend may return a mutable iterator. Such behavior is unexpected for some users. See alsoP2276 andP2278.

[edit]Example

Run this code

#include <algorithm>#include <iostream>#include <vector> 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 w[]={5,10,15};if(std::find(std::begin(w), std::end(w),5)!= std::end(w))std::cout<<"Found a 5 in array w!\n";}

Output:

Found a 5 in array w!

[edit]See also

begincbegin (C++11)(C++14)	returns an iterator to the beginning of a container or array (function template)[edit]
ranges::end (C++20)	returns a sentinel indicating the end of a range (customization point object)[edit]
ranges::cend (C++20)	returns a sentinel indicating the end of a read-only range (customization point object)[edit]