Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
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 /* non spécifié */ reverse = /* non spécifié */ ;

}
(2) (depuis C++20)
Signature d'appel
template < ranges:: viewable_range R >

requires /* voir ci-dessous */

constexpr ranges:: view auto reverse ( R && r ) ;
(depuis C++20)
1) Un adaptateur de gamme qui représente une vue de la view sous-jacente dans l'ordre inverse.
2) RangeAdaptorObject . L'expression views :: reverse ( e ) est équivalente-expression à l'une des expressions suivantes, sauf que e n'est évalué qu'une seule fois :
  • 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éroule 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.

Table des matières

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

construit un reverse_view
(fonction membre publique)
retourne la vue sous-jacente V
(fonction membre publique)
retourne l'itérateur de début du reverse_view
(fonction membre publique)
retourne l'itérateur de fin du reverse_view
(fonction membre publique)
retourne la taille de la vue si elle est bornée
(fonction membre publique)
(C++26)
retourne la taille approximative du approximately_sized_range sous-jacent
(fonction membre publique)
Hérité de std::ranges::view_interface
indique si la vue dérivée est vide, fourni uniquement si elle satisfait sized_range ou forward_range
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un itérateur constant vers le début de la plage
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un sentinelle pour l'itérateur constant de la plage
(fonction membre publique de std::ranges::view_interface<D> )
indique si la vue dérivée n'est pas vide, fourni uniquement si ranges::empty lui est applicable
(fonction membre publique de std::ranges::view_interface<D> )
retourne le premier élément de la vue dérivée, fourni si elle satisfait forward_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le dernier élément de la vue dérivée, fourni uniquement si elle satisfait bidirectional_range et common_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le n ème élément de la vue dérivée, fourni 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)
(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

(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

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