home | help 
std::ranges::cend(3)	       C++ Standard Libary	    std::ranges::cend(3)

NAME
     std::ranges::cend - std::ranges::cend

Synopsis
	Defined in header <ranges>
	Defined in header <iterator>
	inline namespace /* unspecified */ {

	    inline constexpr /* unspecified */ cend = /*	(since C++20)
	unspecified  */;					  (customization
     point object)

	}
	Call signature
	template< class T >

	    requires /* see below */				(since C++20)

	constexpr /* see below */ auto cend( T&& t );

	Returns a sentinel
	for the constant iterator
	(since C++23) indicating the end of a
	const-qualified
	(until C++23) range.

	range-begin-end.svg

	Let CT be

	  * const std::remove_reference_t<T>& if the argument is an lvalue (i.e.
     T is
	    an		     lvalue		  reference		  type),
     (until
	  *		     const		    T		      otherwise.
     C++23)

	A call to ranges::cend is expression-equivalent to
	ranges::end(static_cast<CT&&>(t)).
	If the argument is an lvalue or
	ranges::enable_borrowed_range<std::remove_cv_t<T>> is true, then a  call
     to
	ranges::cend is expression-equivalent to:

	  * std::const_sentinel<decltype(U)>(U) for some expression U equivalent
     to   (since
	    ranges::end(/*possibly-const-range*/(t)).
     C++23)

	In  all other cases, a call to ranges::cend is ill-formed, which can re-
     sult in
	substitution failure when the call appears in the immediate context of a
	template instantiation.

	If ranges::cend(e) is valid for an expression e, where decltype((e))  is
     T, then
	CT models std::ranges::range, and
	(until C++23) std::sentinel_for<S, I> is true in all cases, where S is
	decltype(ranges::cend(e)), and I is decltype(ranges::cbegin(e)).
	Additionally, S models constant-iterator if it models input_iterator.
	(since C++23)

       Customization point objects

	The  name  ranges::cend denotes a customization point object, which is a
     const
	function object of a literal semiregular class type. For exposition pur-
     poses, the
	cv-unqualified version of its type is denoted as __cend_fn.

	All instances of __cend_fn are equal. The effects of invoking  different
     instances of
	type  __cend_fn  on  the  same	arguments  are equivalent, regardless of
     whether the
	expression denoting the instance is an lvalue or rvalue, and  is  const-
     qualified or
	not  (however, a volatile-qualified instance is not required to be invo-
     cable). Thus,
	ranges::cend can be copied freely and its  copies  can	be  used  inter-
     changeably.

	Given  a  set  of types Args..., if std::declval<Args>()... meet the re-
     quirements for
	arguments to ranges::cend above, __cend_fn models

	  * std::invocable<__cend_fn, Args...>,
	  * std::invocable<const __cend_fn, Args...>,
	  * std::invocable<__cend_fn&, Args...>, and
	  * std::invocable<const __cend_fn&, Args...>.

	Otherwise, no function call operator of __cend_fn participates in  over-
     load
	resolution.

Example
     // Run this code

      #include <algorithm>
      #include <cassert>
      #include <ranges>
      #include <vector>

      int main()
      {
	  std::vector vec{3, 1, 4};
	  int arr[]{5, 10, 15};

	  assert(std::ranges::find(vec, 5) == std::ranges::cend(vec));
	  assert(std::ranges::find(arr, 5) != std::ranges::cend(arr));
      }

See also
	ranges::end returns a sentinel indicating the end of a range
	(C++20)     (customization point object)
	end
	cend	    returns an iterator to the end of a container or array
	(C++11)     (function template)
	(C++14)

http://cppreference.com 	   2024.06.10		    std::ranges::cend(3)
home | help