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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::ranges::rend - std::ranges::rend

Synopsis
	  Defined in header <ranges>
	  Defined in header <iterator>
	  inline namespace /* unspecified */ {
									  (since
       C++20)
	      inline  constexpr	 /*  unspecified  */  rend  =  /*  unspecified
       (customization point
	  */;								   ob-
       ject)

	  }
	  Call signature
	  template< class T >

	      requires /* see below */
	  constexpr					    std::sentinel_for<
       (since C++20)

	      decltype(ranges::rbegin(std::declval<T>()))> auto	rend(
	  T&& t	);

	  Returns a sentinel indicating	the end	of a reversed range.

	  range-rbegin-rend.svg

	  If T is an array type	and std::remove_all_extents_t<std::remove_ref-
       erence_t<T>> is
	  incomplete, then the call to ranges::rend is ill-formed, no diagnos-
       tic required.

	  If   the   argument	is   an	   lvalue    or	   ranges::enable_bor-
       rowed_range<std::remove_cv_t<T>>
	  is true, then	a call to ranges::rend is expression-equivalent	to:

	   1. decay-copy(t.rend())
	      (until C++23)
	      auto(t.rend())
	      (since C++23), if	that expression	is valid and its type models
	      std::sentinel_for<decltype(ranges::rbegin(std::declval<T>()))>.
	   2. Otherwise,
	      decay-copy(rend(t))
	      (until C++23)
	      auto(rend(t))
	      (since C++23), if	T is a class or	enumeration type, that expres-
       sion is valid and
	      its    type    models    std::sentinel_for<decltype(ranges::rbe-
       gin(std::declval<T>()))>,
	      where the	meaning	of rend	is established as if by	performing ar-
       gument-dependent
	      lookup only.
	   3. Otherwise, std::make_reverse_iterator(ranges::begin(t)) if  both
       ranges::begin(t)
	      and  ranges::end(t)  are	valid expressions, have	the same type,
       and that	type
	      models std::bidirectional_iterator.

	  In all other cases, a	call to	ranges::rend is	ill-formed, which  can
       result in
	  substitution	failure	 when ranges::rend(t) appears in the immediate
       context of a
	  template instantiation.

Notes
	  If the argument is an	rvalue (i.e. T is an object type) and
	  ranges::enable_borrowed_range<std::remove_cv_t<T>> is	false,	or  if
       it is of	an array
	  type of unknown bound, the call to ranges::rend is ill-formed, which
       also results in
	  substitution failure.

	  If ranges::rend(std::forward<T>(t)) is valid,	then
	  decltype(ranges::rend(std::forward<T>(t))) and
	  decltype(ranges::begin(std::forward<T>(t)))  model std::sentinel_for
       in all cases,
	  while	T models std::ranges::range.

	  The C++20 standard requires that if  the  underlying	rend  function
       call returns a
	  prvalue,  the	return value is	move-constructed from the materialized
       temporary
	  object. All implementations directly return the prvalue instead. The
       requirement is
	  corrected by the post-C++20 proposal P0849R8 to match	the  implemen-
       tations.

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(ranges::rbegin(v),   ranges::rend(v),   5)   !=
       ranges::rend(v))
		std::cout << "found a 5	in vector v!\n";

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

Output:
	found a	5 in array a!

	  Defect reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	    DR	      Applied	  to		   Behavior    as    published
       Correct behavior
	  P2602R2 C++20	     there's machinery to  prohibit  certain	   re-
       moved such machinery
			     non-member	rend found by ADL

See also
	  ranges::crend	 returns a reverse end iterator	to a read-only range
	  (C++20)	 (customization	point object)
	  ranges::rbegin returns a reverse iterator to a range
	  (C++20)	 (customization	point object)
	  rend		 returns a reverse end iterator	for a container	or ar-
       ray
	  crend		 (function template)
	  (C++14)

http://cppreference.com		  2024.06.10		  std::ranges::rend(3)

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

home | help