Namespaces
Variants

std::ranges::views::take, std::ranges::take_view

Depuis fr.cppreference.net
 
 
Bibliothèque de plages
Adaptateurs de plage
 
 
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)
1) Un adaptateur de plage qui représente une vue des éléments d'une séquence sous-jacente, commençant au début et se terminant à une limite donnée.
2) 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)), si T est une ranges::empty_view, sauf que les évaluations de e et f sont séquencées de manière indéterminée ;
  • U(ranges::begin(e), ranges::begin(e) + std::min<D>(ranges::distance(e), f)), si T est 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ù U est
  • std::span<typename T::element_type>, si T est une spécialisation de std::span ;
  • T, si T est une spécialisation de std::basic_string_view ;
  • ranges::subrange<ranges::iterator_t<T>>, si T est une spécialisation de ranges::subrange ;
  • ranges::iota_view(*ranges::begin(e),
    *(ranges::begin(e) + std::min<D>(ranges::distance(e), f)))
    , si T est une spécialisation de ranges::iota_view qui modélise à la fois random_access_range et sized_range ;
  • views::repeat(*e.value_, std::min<D>(ranges::distance(e), f)), si T modélise sized_range ; dans ce cas e n'est évalué qu'une seule fois ;
  • views::repeat(*e.value_, static_cast<D>(e)) sinon ;
(depuis C++23)
  • sinon, take_view(e, f).
Dans tous les cas, 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)
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 >> =

ranges:: enable_borrowed_range < 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

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)
copie un nombre d'éléments vers un nouvel emplacement
(objet fonction algorithme)