std::ranges::views::common, 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 /* unspecified */ common = /* unspecified */;
}
|
(2) | (depuis C++20) |
| Signature d'appel |
||
template< ranges::viewable_range R >
requires /* see below */
constexpr ranges::view auto common( R&& r );
|
(depuis C++20) | |
common_view a toujours le même type d'itérateur/sentinelle.e une sous-expression. Alors l'expression views::common(e) est équivalente en expression à :
views::all(e), si c'est une expression bien formée et quedecltype((e))modélise common_range ;common_view{e}sinon.
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 ranges::view_interface | |
| retourne 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 au 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>)
|
| retourne 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 dans 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 dans 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 nième élément dans 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
>>
=
|
(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
#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) |