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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::ranges::crend - std::ranges::crend

Synopsis
	  Defined in header <ranges>
	  inline namespace /*unspecified*/ {
									  (since
       C++20)
	  inline    constexpr	/*unspecified*/	  crend	  =   /*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 crend(
	  T&& t	);

	  Returns  a  sentinel	indicating  the	end of a const-qualified range
       that is treated as
	  a reversed sequence.

	  range-rbegin-rend.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::crend is expression-equivalent to
	  ranges::rend(static_cast<CT&&>(t)).

	  If  ranges::crend(e)	is  valid  for an expression e,	then std::sen-
       tinel_for<S, I> is
	  true in all cases, where S is	decltype(ranges::crend(e)), and	I is
	  decltype(ranges::crbegin(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::crend 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 __crend_fn.

	  All instances	of __crend_fn are equal. The effects of	invoking  dif-
       ferent instances
	  of  type __crend_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::crend	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::crend above, __crend_fn models

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

	  Otherwise,  no  function call	operator of __crend_fn participates in
       overload
	  resolution.

Example
       // Run this code

	#include <iostream>
	#include <vector>
	#include <iterator>
	#include <algorithm>

	int main()
	{
	    int	a[] = {4, 6, -3, 9, 10};
	    std::cout << "Array	backwards: ";
	    namespace ranges = std::ranges;
	    ranges::copy(ranges::rbegin(a), ranges::rend(a),
			 std::ostream_iterator<int>(std::cout, " "));

	    std::cout << "\nVector backwards: ";
	    std::vector<int> v = {4, 6,	-3, 9, 10};
	    ranges::copy(ranges::rbegin(v), ranges::rend(v),
			 std::ostream_iterator<int>(std::cout, " "));
	}

Output:
	Array backwards: 10 9 -3 6 4
	Vector backwards: 10 9 -3 6 4

See also
	  ranges::rend returns a reverse end iterator to a range
	  (C++20)      (customization point object)
	  rend	       returns a reverse end iterator for a container or array
	  crend	       (function template)
	  (C++14)

http://cppreference.com		  2022.07.31		 std::ranges::crend(3)

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

home | help