std::ranges::views::reverse, std::ranges::reverse_view

Défini dans l'en-tête `<ranges>`
template< ranges::view V > requires ranges::bidirectional_range<V> class reverse_view : public ranges::view_interface<reverse_view<V>>	(1)	(depuis C++20)
namespace views { inline constexpr /* unspecified / reverse = / unspecified */; }	(2)	(depuis C++20)
Signature d'appel
template< ranges::viewable_range R > requires /* see below */ constexpr ranges::view auto reverse( R&& r );		(depuis C++20)

1) Un adaptateur de plage qui représente une vue de la vue sous-jacente dans l'ordre inverse.

2) RangeAdaptorObject. L'expression views::reverse(e) est équivalente à une expression à l'une des expressions suivantes, sauf que e n'est évaluée qu'une seule fois :

e.base(), si le type de e est une spécialisation (éventuellement qualifiée cv) de reverse_view ;
sinon, si le type de e est (éventuellement qualifié cv) ranges::subrange<std::reverse_iterator<I>, std::reverse_iterator<I>, K> pour un certain type d'itérateur I et une valeur K de type ranges::subrange_kind :

ranges::subrange<I, I, K>(e.end().base(), e.begin().base(), e.size()), si K est ranges::subrange_kind::sized ;
sinon ranges::subrange<I, I, K>(e.end().base(), e.begin().base()) ;

sinon ranges::reverse_view{e}.

En d'autres termes, views::reverse déplie les vues inversées si possible.

Un reverse_view modélise toujours bidirectional_range et common_range, et il modélise borrowed_range, sized_range, ou random_access_range si le type de vue sous-jacent V modélise le concept correspondant.

Membres de données

Membre	Description
`V` `base_` (privé)	la vue sous-jacente ( objet membre d'exposition uniquement* )
`non-propagating-cache` < ranges:: iterator_t < V >> `cached_end_` (privé) (présent uniquement si `V` ne satisfait pas `common_range` )	un objet qui met en cache le résultat des appels à `begin()` ( objet membre d'exposition uniquement* )

Fonctions membres

(constructor)	construit un `reverse_view` (fonction membre publique)
base	retourne la vue sous-jacente `V` (fonction membre publique)
begin	retourne l'itérateur de début du `reverse_view` (fonction membre publique)
end	retourne l'itérateur de fin du `reverse_view` (fonction membre publique)
size	retourne la taille de la vue si elle est bornée (fonction membre publique)
reserve_hint (C++26)	retourne la taille approximative du `approximately_sized_range` sous-jacent (fonction membre publique)
Hérité de ranges::view_interface
empty	indique si la vue dérivée est vide, fournie uniquement si elle satisfait `sized_range` ou `forward_range` (fonction membre publique de `std::ranges::view_interface<D>`)
cbegin (C++23)	renvoie un itérateur constant au début de la plage (fonction membre publique de `std::ranges::view_interface<D>`)
cend (C++23)	renvoie un sentinelle pour l'itérateur constant de la plage (fonction membre publique de `std::ranges::view_interface<D>`)
operator bool	indique si la vue dérivée n'est pas vide, fournie uniquement si ranges::empty lui est applicable (fonction membre publique de `std::ranges::view_interface<D>`)
front	renvoie le premier élément de la vue dérivée, fournie si elle satisfait `forward_range` (fonction membre publique de `std::ranges::view_interface<D>`)
back	renvoie le dernier élément de la vue dérivée, fournie uniquement si elle satisfait `bidirectional_range` et `common_range` (fonction membre publique de `std::ranges::view_interface<D>`)
operator[]	renvoie le `n`^ième élément de la vue dérivée, fournie uniquement si elle satisfait `random_access_range` (fonction membre publique de `std::ranges::view_interface<D>`)

std::ranges::reverse_view:: reverse_view

reverse_view ( ) requires std:: default_initializable < V > = default ;	(1)	(since C++20)
constexpr reverse_view ( V r ) ;	(2)	(since C++20)

1) Initialise la valeur de


         
          
           base_

via son initialiseur de membre par défaut ( = V ( ) ).

2) Initialise


         
          
           base_

avec std :: move ( r ) .

Paramètres

r

-

plage à inverser

std::ranges::reverse_view:: base

constexpr V base ( ) const & requires std:: copy_constructible < V > ;	(1)	(since C++20)
constexpr V base ( ) && ;	(2)	(since C++20)

Retourne la vue sous-jacente.

1) Construit par copie le résultat à partir de la vue sous-jacente. Équivalent à return


          
           
            base_

; .

2) Construit par déplacement le résultat à partir de la vue sous-jacente. Équivalent à return std :: move (


          
           
            base_

) ; .

std::ranges::reverse_view:: begin

constexpr std:: reverse_iterator < ranges:: iterator_t < V >> begin ( ) ;	(1)	(depuis C++20)
constexpr std:: reverse_iterator < ranges:: iterator_t < V >> begin ( ) requires ranges:: common_range < V > ;	(2)	(depuis C++20)
constexpr auto begin ( ) const requires ranges:: common_range < const V > ;	(3)	(depuis C++20)

1) Retourne std:: make_reverse_iterator ( ranges:: next ( ranges:: begin (


          
           
            base_

) ,

ranges:: end (


          
           
            base_

) ) ) .

Afin de fournir la complexité temporelle constante amortie requise par le concept


          range

, cette fonction met en cache le résultat dans l'objet de cache pour une utilisation lors des appels ultérieurs.

2,3) Équivalent à return std:: make_reverse_iterator ( ranges:: end (


          
           
            base_

) ) ; .

std::ranges::reverse_view:: end

constexpr std:: reverse_iterator < ranges:: iterator_t < V >> end ( ) ;	(1)	(depuis C++20)
constexpr auto end ( ) const requires ranges:: common_range < const V > ;	(2)	(depuis C++20)

Équivalent à return std:: make_reverse_iterator ( ranges:: begin ( base_ ) ) ; .

std::ranges::reverse_view:: size

constexpr auto size ( ) requires ranges:: sized_range < V > ;	(1)	(depuis C++20)
constexpr auto size ( ) const requires ranges:: sized_range < const V > ;	(2)	(depuis C++20)

Retourne la taille de la vue si celle-ci est bornée. Équivalent à return ranges:: size ( base_ ) ; .

std::ranges::as_rvalue_view:: reserve_hint

constexpr auto reserve_hint ( ) requires ranges :: approximately_sized_range < V > ;	(1)	(depuis C++26)
constexpr auto reserve_hint ( ) const requires ranges :: approximately_sized_range < const V > ;	(2)	(depuis C++26)

Retourne ranges :: reserve_hint ( base_ ) .

Guides de déduction

template < class R > reverse_view ( R && ) - > reverse_view < views:: all_t < R >> ;		(depuis C++20)

Modèles d'assistance

template < class T > constexpr bool enable_borrowed_range < std :: ranges :: reverse_view < T >> = ranges:: enable_borrowed_range < T > ;		(depuis C++20)

Cette spécialisation de std::ranges::enable_borrowed_range permet à reverse_view de satisfaire borrowed_range lorsque la vue sous-jacente la satisfait.

Notes

Macro de test de fonctionnalité	Valeur	Std	Fonctionnalité
`__cpp_lib_ranges_reserve_hint`	`202502L`	(C++26)	ranges::approximately_sized_range et `reserve_hint`

Exemple

Exécuter ce code

#include <iostream>
#include <ranges>
int main()
{
    static constexpr auto il = {3, 1, 4, 1, 5, 9};
    std::ranges::reverse_view rv{il};
    for (int i : rv)
        std::cout << i << ' ';
    std::cout << '\n';
    for (int i : il | std::views::reverse)
        std::cout << i << ' ';
    std::cout << '\n';
    // operator[] is inherited from std::view_interface
    for (auto i{0U}; i != rv.size(); ++i)
        std::cout << rv[i] << ' ';
    std::cout << '\n';
}

Sortie :

9 5 1 4 1 3
9 5 1 4 1 3
9 5 1 4 1 3

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	S'applique à	Comportement publié	Comportement corrigé
LWG 3494	C++20	`reverse_view` n'a jamais été un `borrowed_range`	c'est un `borrowed_range` si sa vue sous-jacente l'est

Voir aussi

reverse_iterator	adaptateur d'itérateur pour le parcours en ordre inverse (modèle de classe)
ranges::reverse (C++20)	inverse l'ordre des éléments dans une plage (objet fonction algorithme)
ranges::reverse_copy (C++20)	crée une copie d'une plage qui est inversée (objet fonction algorithme)

Support du compilateur
Autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostic
Bibliothèque de gestion mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (Ranges) (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque du système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants