Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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 */;					   (customiza-
       tion 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	equiv-
       alent to	  (since
	      ranges::end(/*possibly-const-range*/(t)).
       C++23)

	  In all other cases, a	call to	ranges::cend is	ill-formed, which  can
       result 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_itera-
       tor.
	  (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
       purposes, the
	  cv-unqualified version of its	type is	denoted	as __cend_fn.

	  All  instances  of __cend_fn are equal. The effects of invoking dif-
       ferent 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
       invocable). 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
       requirements 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
       overload
	  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)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::ranges::cend&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help