Namespaces
Variants

std::ranges:: views:: common, std::ranges:: common_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::common_view
Défini dans l'en-tête <ranges>
template < ranges:: view V >

requires ( not ranges:: common_range < V > and
std:: copyable < ranges:: iterator_t < V >> )
class common_view

: public ranges:: view_interface < common_view < V >>
(1) (depuis C++20)
namespace views {

inline constexpr /* non spécifié */ common = /* non spécifié */ ;

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

requires /* voir ci-dessous */

constexpr ranges:: view auto common ( R && r ) ;
(depuis C++20)
1) Adapte une view donnée avec des types différents pour la paire itérateur/sentinelle en une view qui est également une common_range . Un common_view possède toujours le même type d'itérateur/sentinelle.
2) RangeAdaptorObject . Soit e une sous-expression. Alors l'expression views :: common ( e ) est équivalente en expression à :

Table des matières

Membres de données

Membre Description
V base_ (privé) la vue sous-jacente
( objet membre d'exposition uniquement* )

Fonctions membres

construit un common_view
(fonction membre publique)
retourne une copie de la vue sous-jacente (adaptée)
(fonction membre publique)
retourne un itérateur vers le début
(fonction membre publique)
retourne un itérateur vers la fin
(fonction membre publique)
retourne le nombre d'éléments, fourni uniquement si la plage sous-jacente (adaptée) satisfait sized_range
(fonction membre publique)
(C++26)
retourne la taille approximative de la approximately_sized_range résultante
(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> )
obtient l'adresse des données de la vue dérivée, fourni uniquement si son type d'itérateur satisfait contiguous_iterator
(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> )

Guides de déduction

Modèles d'assistance

template < class T >

constexpr bool enable_borrowed_range < std :: ranges :: common_view < T >> =

ranges:: enable_borrowed_range < T > ;
(depuis C++20)

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

Notes

common_view peut être utile pour travailler avec des algorithmes hérités qui s'attendent à ce que l'itérateur et le sentinelle soient du même type.

Exemple

Exécuter ce code 
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <list>
#include <numeric>
#include <ranges>
int main()
{
    auto v1 = {1, 2, 3, 4, 5};
    auto i1 = std::counted_iterator{v1.begin(), std::ssize(v1)};
    auto r1 = std::ranges::subrange{i1, std::default_sentinel};
//  auto e1 = std::accumulate(r1.begin(), r1.end(), 0); // erreur : "common range" requis
    auto c1 = std::ranges::common_view{r1};
    std::cout << "accumulate: " << std::accumulate(c1.begin(), c1.end(), 0) << '\n';
    // hérité de ranges::view_interface :
    std::cout << "c1.front(): " << c1.front() << '\n';
    std::cout << "c1.back(): " << c1.back() << '\n';
    std::cout << "c1.data(): " << c1.data() << '\n';
    std::cout << "c1[0]: " << c1[0] << '\n';
    auto v2 = std::list{1, 2, 3, 4, 5};
    auto i2 = std::counted_iterator{v2.begin(), std::ssize(v2)};
    auto r2 = std::ranges::subrange{i2, std::default_sentinel};
//  auto e2 = std::accumulate(r2.begin(), r2.end(), 0); // erreur : "common range" requis
    auto c2 = std::ranges::common_view{ r2 };
    std::cout << "accumulate: " << std::accumulate(c2.begin(), c2.end(), 0) << '\n';
    // hérité de ranges::view_interface :
    std::cout << "c2.front(): " << c2.front() << '\n';
//  auto e3 = c2.back(); // erreur : "bidirectional range" requis
//  auto e4 = c2.data(); // erreur : "contiguous range" requis
//  auto e5 = c2[0];     // erreur : "random access range" requis
}

Sortie possible : 

accumulate: 15
c1.front(): 1
c1.back(): 5
c1.data(): 0x7f19937f00d0
c1[0]: 1
accumulate: 15
c2.front(): 1

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 Appliqué à Comportement publié Comportement corrigé
LWG 3494 C++20 common_view n'était jamais un borrowed_range c'est un borrowed_range si sa vue sous-jacente l'est

Voir aussi

(C++20)
spécifie qu'une plage a des types d'itérateur et de sentinelle identiques
(concept)
(C++20)
adapte un type d'itérateur et sa sentinelle en un type d'itérateur commun
(modèle de classe)