std::rend,std::crend(3)

NAME
std::rend,std::crend - std::rend,std::crend

Synopsis
   Defined in header <array>
   Defined in header <deque>
   Defined in header <forward_list>
   Defined in header <iterator>
   Defined in header <list>
   Defined in header <map>
   Defined in header <regex>
   Defined in header <set>
   Defined in header <span> (since
                        C++20)
   Defined in header <string>
   Defined in header <string_view> (since
                        C++17)
   Defined in header <unordered_map>
   Defined in header <unordered_set>
   Defined in header <vector>
   template< class C > (since
   auto rend( C& c ) -> C++14)
   decltype(c.rend()); (until
                        C++17)
   template< class C > (since
   constexpr auto rend( C& c ) -> C++17)
   decltype(c.rend());
   template< class C > (since
   auto rend( const C& c ) -> C++14)
   decltype(c.rend()); (until
                        C++17)
   template< class C > (since
   constexpr auto rend( const C& c ) C++17)
   -> decltype(c.rend());
   template< class T, std::size_t N (since
   > C++14)
   std::reverse_iterator<T*> rend( T (until
   (&array)[N] ); C++17)
   template< class T, std::size_t N
   > (1) (since
   constexpr C++17)
   std::reverse_iterator<T*> rend( T
   (&array)[N] ); (1)
   template< class T > (since
   std::reverse_iterator<const T*> C++14)
   rend( std::initializer_list<T> il (until
   ); (2) C++17)
   template< class T >
   constexpr (since
   std::reverse_iterator<const T*> C++17)
   rend( std::initializer_list<T> il (3)
   );
   template< class C > (since
   auto crend( const C& c ) -> C++14)
   decltype(std::rend(c)); (until
                        (4) C++17)
   template< class C > (since
   constexpr auto crend( const C& c C++17)
   ) -> decltype(std::rend(c));
   Returns an iterator to the reverse-end of the given range.
   1) Returns an iterator to the reverse-end of the possibly const-qualified container
   or view c.
   2) Returns std::reverse_iterator<T*> to the reverse-end of the array array.
   3) Returns std::reverse_iterator<const T*> to the reverse-end of the
   std::initializer_list il.
   4) Returns an iterator to the reverse-end of the const-qualified container or view
   c.
   range-rbegin-rend.svg

Parameters
   c - a container or view with a rend member function
   array - an array of arbitrary type
   il - an initializer_list

Return value
   1) c.rend()
   2) std::reverse_iterator<T*>(array)
   3) std::reverse_iterator<const T*>(il.begin())
   4) c.rend()

Exceptions
   May throw implementation-defined exceptions.
  Overloads
   Custom overloads of rend may be provided for classes and enumerations that do not
   expose a suitable rend() member function, yet can be iterated.
   Overloads of rend found by argument-dependent lookup can be used to (since C++20)
   customize the behavior of std::ranges::rend and std::ranges::crend.

Notes
   The overload for std::initializer_list is necessary because it does not have a
   member function rend.

Example
// Run this code
 #include <iostream>
 #include <vector>
 #include <iterator>
 #include <algorithm>
 int main()
 {
     int a[] = {4, 6, -3, 9, 10};
     std::cout << "C-style array `a` backwards: ";
     std::copy(std::rbegin(a), std::rend(a), std::ostream_iterator<int>(std::cout, " "));
     auto il = { 3, 1, 4 };
     std::cout << "\nstd::initializer_list `il` backwards: ";
     std::copy(std::rbegin(il), std::rend(il), std::ostream_iterator<int>(std::cout, " "));
     std::cout << "\nstd::vector `v` backwards: ";
     std::vector<int> v = {4, 6, -3, 9, 10};
     std::copy(std::rbegin(v), std::rend(v), std::ostream_iterator<int>(std::cout, " "));
 }

Output:
 C-style array `a` backwards: 10 9 -3 6 4
 std::initializer_list `il` backwards: 4 1 3
 std::vector `v` backwards: 10 9 -3 6 4

See also
   end
   cend returns an iterator to the end of a container or array
   (C++11) (function template)
   (C++14)
   rbegin returns a reverse iterator to the beginning of a container or array
   crbegin (function template)
   (C++14)
   begin
   cbegin returns an iterator to the beginning of a container or array
   (C++11) (function template)
   (C++14)
   ranges::rend returns a reverse end iterator to a range
   (C++20) (customization point object)
   ranges::crend returns a reverse end iterator to a read-only range
   (C++20) (customization point object)