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

NAME
     std::ranges::crbegin - std::ranges::crbegin

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

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

	}
	Call signature
	template< class T >

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

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

	Returns  an  iterator  to  the	first  element	of  the  const-qualified
     (until C++23)
	argument that is treated as a reversed sequence.
	Returns  a  constant  iterator to the first element of the argument that
     (since C++23)
	is treated as a reversed sequence.

	range-rbegin-rend.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::crbegin is expression-equivalent to
	ranges::rbegin(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::crbegin is expression-equivalent to:

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

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

	The return type models std::input_or_output_iterator
	and constant-iterator
	(since C++23) in all cases.

       Customization point objects

	The  name ranges::crbegin 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 __crbegin_fn.

	All instances of __crbegin_fn are equal. The effects of invoking differ-
     ent instances
	of type __crbegin_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::crbegin 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::crbegin above, __crbegin_fn models

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

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

Example
     // Run this code

      #include <cassert>
      #include <iterator>
      #include <span>
      #include <vector>

      int main()
      {
	  std::vector<int> v{3, 1, 4};
	  auto vi = std::ranges::crbegin(v);
	  assert(*vi == 4);
	  ++vi; // OK, iterator object is mutable
	  assert(*vi == 1);
	  // *vi = 13; // Error: underlying element is read-only

	  int a[]{-5, 10, 15};
	  auto ai = std::ranges::crbegin(a);
	  assert(*ai == 15);

	  // auto x_x = std::ranges::crbegin(std::vector<int>{6, 6, 6});
	  // ill-formed: the argument is an rvalue (see Notes a)

	  auto si = std::ranges::crbegin(std::span{a}); // OK
	  assert(*si == 15);
	  static_assert
	  (
	      std::ranges::enable_borrowed_range<std::remove_cv_t<de-
     cltype(std::span{a})>>
	  );
      }

See also
	ranges::rbegin returns a reverse iterator to a range
	(C++20)        (customization point object)
	rbegin		returns  a  reverse  iterator to the beginning of a con-
     tainer or array
	crbegin        (function template)
	(C++14)

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