owning_view classe (bibliothèque standard C++)

Vue qui prend possession des éléments d’une autre plage.

Syntaxe

template<range R>
    requires std::movable<R> && (!is-initializer-list<R>)
class owning_view : public ranges::view_interface<owning_view<R>>;

Paramètres de modèle

R
Type de la plage sous-jacente.

Afficher les caractéristiques

Pour obtenir une description des entrées suivantes, consultez les caractéristiques de classe View

Membres

Notes

La meilleure façon de créer un owning_view est d’utiliser l’adaptateur views::all de plage. Les adaptateurs de plage sont la méthode prévue pour créer des classes d’affichage. Les types d’affichage sont exposés au cas où vous souhaitez créer votre propre type d’affichage personnalisé.

Même si cette classe possède ses éléments, il n’est pas coûteux de construire, car la plage sous-jacente est déplacée à l’aide std::move().

Cette vue est utile lorsque vous souhaitez une plage qui ne dépend pas de la durée de vie du conteneur fournissant les éléments.

Spécifications

En-tête : <ranges> (depuis C++20)

Espace de noms : std::ranges

Option du compilateur : /std:c++20 ou version ultérieure est requise.

Constructeurs

Créez une instance de owning_view.

1) owning_view() requires default_initializable<R> = default;
2) constexpr owning_view(R&& rg); 
3) owning_view(const owning_view& v) = delete; // no copy constructor 
4) owning_view(const owning_view&& v) = default; // move constructor

Paramètres

rg
Plage à déplacer vers le owning_view.

v
À owning_view déplacer vers le nouveau owning_view.

Pour plus d’informations sur les types de paramètres de modèle, consultez Paramètres de modèle.

Notes

1) Le constructeur par défaut crée un initialisé owning_viewpar défaut.
2) Déplacer les constructions de rg.owning_view
3) Impossible owning_view de copier un objet, uniquement déplacé.
4) Construire à partir d’un owning_view autre owning_view.

Exemple : owning_view

// requires /std:c++20 or later
#include <ranges>
#include <iostream>
#include <vector>
#include <utility>

int main()
{
    std::vector<int> v = {1,2,3,4,5,6,7,8,9,10};
    auto myOwningView = std::views::all(std::move(v)); // create an owning_view from a moved vector
    std::cout << v.size() << '\n'; // outputs 0 because myOwningView now owns the elements
    std::cout << myOwningView.size() << '\n'; // outputs 10

    std::vector<int> v2 = {1,2,3,4,5};
    std::ranges::owning_view<std::vector<int>> ov2{std::move(v2)};
    std::cout << v2.size() << '\n'; // outputs 0 because ov2 now owns the elements
    std::cout << ov2.size() << '\n'; // outputs 5
}

0
10
0
5

base

Obtient une référence à la plage sous-jacente.

1) constexpr R& base() & noexcept { return r_; }
2) constexpr const R& base() const & noexcept { return r_; }
3) constexpr R&& base() && noexcept { return std::move(r_); }
4) constexpr const R&& base() const && noexcept { return std::move(r_); }

Paramètres

Aucune.

Valeur retournée

Référence à la plage sous-jacente, appelez-la rg.
Pour 1 &2, la plage sous-jacente est retournée via return rg;
Pour 3 et 4, la plage sous-jacente est retournée via std::move(rg);

begin

Obtenez un itérateur sur le premier élément de la vue.

constexpr iterator_t<R> begin();
constexpr auto begin() const requires range<const R>;

Paramètres

Aucune.

Valeur retournée

Itérateur pointant vers le premier élément de la vue :

data

Obtenez un pointeur vers le premier élément de la vue.

constexpr auto data()
    requires std::contiguous_iterator<ranges::iterator_t<R>>;
constexpr auto data() const
    requires std::contiguous_iterator<ranges::iterator_t<const R>>;

Paramètres

Aucune.

Valeur retournée

Pointeur vers le premier élément de la vue.

Notes

La plage détenue sous-jacente doit satisfaire contiguous_range.

empty

Testez si la vue est vide.

constexpr bool empty();
constexpr bool empty() const;

Paramètres

Aucune.

Valeur retournée

Retourne true si la plage sous-jacente n’a aucun élément. Sinon, retourne false.

end

Obtenez la sentinelle à la fin de la vue.

constexpr sentinel_t<R> end();
constexpr auto end() const requires range<const R>

Valeur retournée

Sentinel qui suit le dernier élément de la vue :

size

Obtenez le nombre d’éléments dans la vue.

constexpr auto size() requires ranges::sized_range<R>;
constexpr auto size() const requires ranges::sized_range<const R>;

Paramètres

Aucune.

Valeur retournée

Nombre d’éléments dans la vue.

operator=

Affectez (déplacez) le contenu d’un autre owning_view à celui-ci.

owning_view& operator=(owning_view&&) = default;

Paramètres

À owning_view attribuer (déplacer) à celui-ci.

Valeur retournée

*this

Notes

Impossible owning_view de copier un fichier, uniquement déplacé.

Exemple : operator=

// requires /std:c++20 or later
#include <ranges>
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v1 = {1,2,3};
    std::ranges::owning_view<std::vector<int>> ov1{std::move(v1)};
    
    std::vector<int> v2 = {4,5,6};
    std::ranges::owning_view<std::vector<int>> ov2{std::move(v2)};
    
    // operator=
    ov2 = std::move(ov1);

    // ov1 took ownership of v1, so v1 is empty
    // ov2 took ownership of v2, so v2 is empty
    // ov2 then took ownership of ov1, so ov1 is empty
    // ov2 now owns the elements 1, 2, 3

    std::cout << std::boolalpha << "v1.empty():" << v1.empty() << " ov1.empty():" << ov1.empty() << '\n'; // v1.empty():true ov1.empty():true
    std::cout << "v2.empty():" << v2.empty() << " ov2.size():" << ov2.size() << '\n'; // v2.empty():true ov2.size():3

    for (auto e : ov2)
    {
         std::cout << e << ' '; // 1 2 3
    }
}

v1.empty():true ov1.empty():true
v2.empty():true ov2.size():3
1 2 3

Voir aussi

<ranges>
all adaptateur de plage
afficher les classes