std::ranges::views::take, std::ranges::take_view
| Défini dans l'en-tête <ranges>
|
||
template< ranges::view V >
class take_view
: public ranges::view_interface<take_view<V>>
|
(1) | (depuis C++20) |
namespace views {
inline constexpr /* unspecified */ take = /* unspecified */;
}
|
(2) | (depuis C++20) |
| Signature d'appel |
||
template< ranges::viewable_range R >
requires /* see below */
constexpr ranges::view auto
take( R&& r, ranges::range_difference_t<R> count );
|
(depuis C++20) | |
template< class DifferenceType >
constexpr /* range adaptor closure */ take( DifferenceType&& count );
|
(depuis C++20) | |
views::take est un RangeAdaptorObject. L'expression views::take(e, f) produit une vue qui représente les premiers f éléments de e. Le résultat n'est pas nécessairement une take_view.
views::take(e, f) est expression-équivalent à (où T est std::remove_cvref_t<decltype((e))> et D est ranges::range_difference_t<decltype((e))>) :
((void)f,decay-copy(e)), siTest uneranges::empty_view, sauf que les évaluations deeetfsont séquencées de manière indéterminée ;U(ranges::begin(e), ranges::begin(e) + std::min<D>(ranges::distance(e), f)), siTest une spécialisation de std::span, std::basic_string_view, ou ranges::subrange qui modélise à la fois random_access_range et sized_range, oùUest
std::span<typename T::element_type>, siTest une spécialisation de std::span ;T, siTest une spécialisation de std::basic_string_view ;ranges::subrange<ranges::iterator_t<T>>, siTest une spécialisation de ranges::subrange ;
ranges::iota_view(*ranges::begin(e),*(ranges::begin(e) + std::min<D>(ranges::distance(e), f))), siTest une spécialisation de ranges::iota_view qui modélise à la fois random_access_range et sized_range ;
|
(depuis C++23) |
- sinon,
take_view(e, f).
decltype((f)) doit modéliser std::convertible_to<D>.take_view modélise les concepts contiguous_range, random_access_range, bidirectional_range, forward_range, input_range, et sized_range lorsque la vue sous-jacente V modélise les concepts respectifs. Elle modélise common_range lorsque la vue sous-jacente V modélise à la fois random_access_range et sized_range.
Membres de données
| Membre | Description |
V
base_
|
la vue sous-jacente
( objet membre d'exposition uniquement* ) |
ranges::
range_difference_t
<
V
>
count_
|
le nombre d'éléments à prendre
( objet membre d'exposition uniquement* ) |
Fonctions membres
construit un
take_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 ou un sentinelle 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ée de ranges::view_interface | |
| 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>)
| |
(C++23) |
renvoie un itérateur constant vers le début de la plage (fonction membre publique de std::ranges::view_interface<D>)
|
(C++23) |
renvoie 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, fournie 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, fournie uniquement si le type de son itérateur satisfait contiguous_iterator (fonction membre publique de std::ranges::view_interface<D>)
| |
| 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>)
| |
| 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>)
| |
renvoie le ni-è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>)
| |
Guides de déduction
Classes imbriquées
|
(C++20)
|
le type sentinelle
( classe membre template uniquement pour exposition* ) |
Modèles d'assistance
|
template
<
class
T
>
constexpr
bool
enable_borrowed_range
<
std
::
ranges
::
take_view
<
T
>>
=
|
(depuis C++20) | |
Cette spécialisation de
ranges::enable_borrowed_range
permet à
take_view
de satisfaire
borrowed_range
lorsque la vue sous-jacente la satisfait.
Exemple
#include <algorithm> #include <iostream> #include <ranges> int main() { namespace views = std::views; auto print = [](char x){ std::cout << x; }; for (const char nums[]{'1', '2', '3'}; int n : views::iota(0, 5)) { std::cout << "take(" << n << "): "; // prend uniquement jusqu'à min(n, nums.size()) éléments de manière sécurisée : std::ranges::for_each(nums | views::take(n), print); std::cout << '\n'; } }
Sortie :
take(0): take(1): 1 take(2): 12 take(3): 123 take(4): 123
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 3407 | C++20 |
views::take
échouait parfois à
construire une plage à accès aléatoire dimensionnée |
le type de résultat est ajusté pour
que la construction soit toujours valide |
| LWG 3494 | C++20 |
take_view
n'était jamais une
borrowed_range
|
c'est une
borrowed_range
si sa vue sous-jacente l'est
|
Voir aussi
|
(C++20)
|
crée un sous-intervalle à partir d'un itérateur et d'un compteur
(objet de point de personnalisation) |
une
view
composée des éléments initiaux d'une autre
view
, jusqu'au premier élément sur lequel un prédicat retourne
false
(modèle de classe) (objet adaptateur de plage) |
|
|
(C++20)
|
copie un nombre d'éléments vers un nouvel emplacement
(objet fonction algorithme) |