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
| Caractéristique | Description |
|---|---|
| Adaptateur de plage | views::all |
| Plage sous-jacente | Doit satisfaire input_range ou supérieur |
| Type d’élément | Identique à la plage sous-jacente |
| Afficher la catégorie d’itérateur | Identique à la plage sous-jacente |
| Taille | Uniquement si la plage sous-jacente satisfait sized_range |
Est const-itérable |
Uniquement si la plage sous-jacente satisfait const-iterable |
| Plage commune | Uniquement si la plage sous-jacente satisfait common_range |
| Plage empruntée | Uniquement si la plage sous-jacente satisfait borrowed_range |
Membres
| Fonctions membres | Description |
|---|---|
| Constructeurs | Construire un owning_view. |
baseC++20 |
Obtenez une référence à la plage détenue. |
beginC++20 |
Obtenez un itérateur au premier élément. |
dataC++20 |
Obtenez un pointeur vers le premier élément. |
emptyC++20 |
Testez si la vue est vide. |
endC++20 |
Obtenez la sentinelle à la fin de la vue. |
sizeC++20 |
Obtenez le nombre d’éléments. |
operator= |
Affectez (déplacez) le contenu d’un autre owning_view à celui-ci. |
Hérité de view_interface |
Description |
backC++20 |
Obtenez le dernier élément. |
frontC++20 |
Obtenez le premier élément. |
operator[]C++20 |
Obtenez l’élément à la position spécifiée. |
operator boolC++20 |
Testez si la vue n’est pas vide. |
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