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

💖 NAME 💖

std::rend, std::crend — the reverse-end iterator duo, aka the "bestie, go backwards" squad 💅

(Yeah the original page literally just says std::rend,std::crend in the NAME section and honestly? Iconic minimalism. But you're getting the full story below.)

---

✨ SYNOPSIS ✨

So first things first, these functions live in a lot of headers. Like, a concerning amount. It's giving "shows up everywhere" 👑

Defined in header <array>

Defined in header <deque>

Defined in header <flat_map>

Defined in header <flat_set>

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>

Defined in header <string>

Defined in header <string_view>

Defined in header <unordered_map>

Defined in header <unordered_set>

Defined in header <vector>

Okay now the actual signatures. Buckle up, there's five of them, numbered, and the version tags are doing the most 🫠

template< class C >
auto rend( C& c ) ->
decltype(c.rend());

(since C++14), (until C++17)

template< class C >
constexpr auto rend( C& c ) ->
decltype(c.rend());

(since C++17)

template< class C >
auto rend( const C& c ) ->
decltype(c.rend());

(since C++14), (until C++17)

template< class C >
constexpr auto rend( const C& c ) ->
decltype(c.rend());

(since C++17)

Overload (1):

template< class T, std::size_t N >
std::reverse_iterator<T*> rend( T (&array)[N] );

(since C++14), (until C++17)

template< class T, std::size_t N >
constexpr std::reverse_iterator<T*> rend( T (&array)[N] );

(since C++17)

Overload (2):

template< class T >
std::reverse_iterator<const T*> rend( std::initializer_list<T> il );

(since C++14), (until C++17)

Overload (3):

template< class T >
constexpr std::reverse_iterator<const T*> rend( std::initializer_list<T> il );

(since C++17)

Overload (4):

template< class C >
auto crend( const C& c ) ->
decltype(std::rend(c));

(since C++14), (until C++17)

Overload (5):

template< class C >
constexpr auto crend( const C& c ) -> decltype(std::rend(c));

(since C++17)

---

🦋 What it actually does 🦋

Returns an iterator to the reverse-end of the given range. No cap, that's the whole vibe. It's the "you've reached the end of going backwards" marker 🔥

• 1,2) Returns c.rend(), which is typically an iterator one past the reverse-end of the sequence represented by c.
  • 1) If C is a standard Container, returns a C::reverse_iterator object.
  • 2) If C is a standard Container, returns a C::const_reverse_iterator object.
• 3) Returns an std::reverse_iterator<T*> object to the reverse-end of array.
• 4) Returns an std::reverse_iterator<const T*> object to the reverse-end of il.
• 5) Returns std::end(c), with c always treated as const-qualified. If C is a standard Container, returns a C::const_reverse_iterator object.

Also, the original page has a whole diagram in here called range-rbegin-rend.svg — if you're reading this on cppreference dot com, that's the little picture showing you which way round everything goes 💖

---

🎀 PARAMETERS 🎀

• c — a container or view with a rend member function
• array — an array of arbitrary type
• il — an std::initializer_list

---

👑 RETURN VALUE 👑

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

---

💀 EXCEPTIONS 💀

May throw implementation-defined exceptions. So like... ask your implementation. It knows. We don't 😭

---

🌈 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. Slay, you do you 💅

(since C++20) — Overloads of rend found by argument-dependent lookup can be used to customize the behavior of std::ranges::rend and std::ranges::crend. ADL customization, we love to see it ✨

---

🌸 NOTES 🌸

The overload for std::initializer_list is necessary because it does not have a member function rend. That's literally the entire reason it exists — it's a workaround bestie and it's thriving 🧚

---

🍓 EXAMPLE 🍓

// Run this code

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

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::vector<int> v{4, 6, -3, 9, 10};
    std::cout << "\nstd::vector `v` backwards: ";
    std::copy(std::rbegin(v), std::rend(v),
    std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
}

⭐ 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 (C++11), (C++14) — returns an iterator to the end of a container or array (function template)
• rbegin, crbegin (C++14) — returns a reverse iterator to the beginning of a container or array (function template)
• begin, cbegin (C++11), (C++14) — returns an iterator to the beginning of a container or array (function template)
• ranges::rend (C++20) — returns a reverse end iterator to a range (customization point object)
• ranges::crend (C++20) — returns a reverse end iterator to a read-only range (customization point object)

---

💜 Okay that's the whole page, bestie. You ate that. Go forth and iterate backwards with confidence.

Fr fr, this one's from http://cppreference.com, page std::rend,std::crend(3), dated 2024.06.10. Mwah 💋