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>
	  inline namespace /*unspecified*/ {
									  (since
       C++20)
	  inline    constexpr	 /*unspecified*/   cend	  =   /*unspecified*/;
       (customization point
									  ob-
       ject)
	  }
	  Call signature
	  template< class T >

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

	  constexpr std::sentinel_for<ranges::iterator_t<T>> auto cend(
	  T&& t	);

	  Returns a sentinel indicating	the end	of a const-qualified range.

	  range-begin-end.svg

	  Let CT be

	   1.  const  std::remove_reference_t<T>&  if the argument is a	lvalue
       (i.e. T is an
	      lvalue reference type),
	   2. const T otherwise,

	  a call to ranges::cend is expression-equivalent to
	  ranges::end(static_cast<CT&&>(t)).

	  If ranges::cend(e) is	valid for an expression	e, where decltype((e))
       is T, then CT
	  models std::ranges::range, and std::sentinel_for<S, I>  is  true  in
       all cases, where	S
	  is decltype(ranges::cend(e)),	and I is decltype(ranges::cbegin(e)).

	 Expression-equivalent

	  Expression e is expression-equivalent	to expression f, if

	    * e	and f have the same effects, and
	    *  either  both  are  constant subexpressions or else neither is a
       constant
	      subexpression, and
	    * either both are potentially-throwing or else neither  is	poten-
       tially-throwing
	      (i.e. noexcept(e)	== noexcept(f)).

	 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 <iostream>
	#include <ranges>
	#include <vector>

	int main()
	{
	    std::vector<int> v = { 3, 1, 4 };
	    namespace ranges = std::ranges;
	    if (ranges::find(v,	5) != ranges::cend(v)) {
		std::cout << "found a 5	in vector v!\n";
	    }

	    int	a[] = {	5, 10, 15 };
	    if (ranges::find(a,	5) != ranges::cend(a)) {
		std::cout << "found a 5	in array a!\n";
	    }
	}

Output:
	found a	5 in array a!

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		  2022.07.31		  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.0>

home | help