std:: reverse_iterator

std::reverse_iterator est un adaptateur d'itérateur qui inverse la direction d'un itérateur donné, qui doit être au moins un LegacyBidirectionalIterator ou modéliser bidirectional_iterator (depuis C++20) . En d'autres termes, lorsqu'il est fourni avec un itérateur bidirectionnel, std::reverse_iterator produit un nouvel itérateur qui se déplace de la fin vers le début de la séquence définie par l'itérateur bidirectionnel sous-jacent.

Pour un itérateur inverse r construit à partir d'un itérateur i , la relation & * r == & * ( i - 1 ) est toujours true (tant que r est déréférençable ) ; ainsi un itérateur inverse construit à partir d'un itérateur pointant après le dernier élément déréférence vers le dernier élément d'une séquence.

Ceci est l'itérateur retourné par les fonctions membres rbegin() et rend() des conteneurs de la bibliothèque standard .

Types imbriqués

1. ↑ ^{1.0 1.1} La définition est fournie par la spécialisation de base std::iterator jusqu'à C++17.

Membres de données

Fonctions membres

Fonctions non membres

Modèles d'assistance

Cette spécialisation partielle de std::disable_sized_sentinel_for empêche les spécialisations de reverse_iterator de satisfaire sized_sentinel_for si leurs itérateurs sous-jacents ne satisfont pas le concept.

Implémentation possible

Voici une implémentation partielle se concentrant sur la manière dont l'itérateur interne est stocké, appelant std::prev uniquement lorsque le contenu est récupéré via operator * .

template<class It>
class reverse_iterator
{
protected:
    It current = It();
public:
    reverse_iterator() = default;
    constexpr explicit reverse_iterator(It itr) : current(itr) {}
    template<class U>
        requires (!std::is_same_v<U, It> && std::convertible_to<const U&, It>)
    constexpr explicit reverse_iterator(const U& other) : current(other.base()) {}
    constexpr decltype(auto) operator*() const
    {
        return *std::prev(current); // <== retourne le contenu de prev
    }
    constexpr reverse_iterator& operator++() { --current; return *this; }
    constexpr reverse_iterator operator++(int) { auto tmp = *this; ++(*this); return tmp; }
    constexpr reverse_iterator& operator--() { ++current; return *this; }
    constexpr reverse_iterator operator--(int) { auto tmp = *this; --(*this); return tmp; }
    constexpr It base() const { return current; }
    // Les autres fonctions membres, fonctions amies et typedefs membres ne sont pas affichés ici.
};

Notes

std::reverse_iterator ne fonctionne pas avec les itérateurs dont le déréférencement renvoie une référence à un membre de * this (appelés « itérateurs de stockage »). Un exemple d'itérateur de stockage est celui de MSVC STL std::filesystem::path::iterator .

Exemple

#include <cstddef>
#include <iostream>
#include <iterator>
template<typename T, std::size_t SIZE>
class Stack
{
    T arr[SIZE];
    std::size_t pos = 0;
public:
    T pop()
    {
        return arr[--pos];
    }
    Stack& push(const T& t)
    {
        arr[pos++] = t;
        return *this;
    }
    // nous souhaitons que le parcours de Stack soit dans l'ordre LIFO
    // donc nous utilisons std::reverse_iterator comme adaptateur aux itérateurs existants
    // (qui sont dans ce cas des pointeurs simples : [arr, arr + pos)
    auto begin() { return std::reverse_iterator(arr + pos); }
    auto end() { return std::reverse_iterator(arr); }
};
int main()
{
    Stack<int, 8> s;
    s.push(5).push(15).push(25).push(35);
    for (int val : s)
        std::cout << val << ' ';
    std::cout << '\n';
}

35 25 15 5

Voir aussi