Namespaces
Variants

std::ranges:: views:: single, std::ranges:: single_view

From cppreference.net
C++
Ranges library
Range adaptors
Défini dans l'en-tête <ranges>
(1)
template < std:: copy_constructible T >

requires std:: is_object_v < T >
class single_view

: public ranges:: view_interface < single_view < T >>
(depuis C++20)
(jusqu'à C++23)
template < std:: move_constructible T >

requires std:: is_object_v < T >
class single_view

: public ranges:: view_interface < single_view < T >>
(depuis C++23)
namespace views {

inline constexpr /* non spécifié */ single = /* non spécifié */ ;

}
(2) (depuis C++20)
Signature d'appel
template < class T >

requires /* voir ci-dessous */

constexpr /* voir ci-dessous */ single ( T && t ) ;
(depuis C++20)
1) Produit une view qui contient exactement un élément d'une valeur spécifiée.
2) L'expression views :: single ( e ) est équivalente en expression à single_view < std:: decay_t < decltype ( ( e ) ) >> ( e ) pour toute sous-expression appropriée e .

La durée de vie de l'élément est liée au parent single_view . La copie du single_view effectue une copie de l'élément.

Table des matières

Objets de point de personnalisation

Le nom views::single désigne un objet de point de personnalisation , qui est un objet fonction constant d'un type de classe littéral semiregular . Voir CustomizationPointObject pour plus de détails.

Membres de données

Membre Définition
copyable-box  <T> value_ (jusqu'en C++23) l'élément unique de la vue
( objet membre d'exposition uniquement* )
movable-box  <T> value_ (depuis C++23) l'élément unique de la vue
( objet membre d'exposition uniquement* )

Fonctions membres

construit un single_view
(fonction membre publique)
retourne un pointeur vers l'élément
(fonction membre publique)
retourne un pointeur après l'élément
(fonction membre publique)
[static]
retourne false
(fonction membre statique publique)
[static]
retourne 1
(fonction membre statique publique)
retourne un pointeur vers l'élément
(fonction membre publique)
Hérité de std::ranges::view_interface
(C++23)
retourne un itérateur constant vers le 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> )
retourne le premier élément de 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 de 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 n ème élément de la vue dérivée, fourni uniquement si elle satisfait random_access_range
(fonction membre publique de std::ranges::view_interface<D> )

std::ranges::single_view:: single_view

single_view ( ) requires std:: default_initializable < T > = default ;
(1) (depuis C++20)
(2)
constexpr explicit single_view ( const T & t ) ;
(depuis C++20)
(jusqu'à C++23)
constexpr explicit single_view ( const T & t )
requires std:: copy_constructible < T > ;
(depuis C++23)
constexpr explicit single_view ( T && t ) ;
(3) (depuis C++20)
template < class ... Args >

requires std:: constructible_from < T, Args... >

constexpr explicit single_view ( std:: in_place_t , Args && ... args ) ;
(4) (depuis C++20)

Construit un single_view .

1) Initialise par défaut value_ , ce qui initialise par valeur son contenu.
2) Initialise value_ avec t .
3) Initialise value_ avec std :: move ( t ) .
4) Initialise value_ comme si par value_ { std:: in_place , std:: forward < Args > ( args ) ... } .

std::ranges::single_view:: begin

constexpr T * begin ( ) noexcept ;
constexpr const T * begin ( ) const noexcept ;
(depuis C++20)

Équivalent à return data ( ) ; .

std::ranges::single_view:: end

constexpr T * end ( ) noexcept ;
constexpr const T * end ( ) const noexcept ;
(depuis C++20)

Équivalent à return data ( ) + 1 ; .

std::ranges::single_view:: empty

static constexpr bool empty ( ) noexcept ;
(depuis C++20)

Équivalent à return false ; .

std::ranges::single_view:: size

static constexpr std:: size_t size ( ) noexcept ;
(depuis C++20)

Équivalent à return 1 ; .

Permet à single_view de modéliser /*tiny-range*/ comme requis par split_view .

std::ranges::single_view:: data

constexpr T * data ( ) noexcept ;
constexpr const T * data ( ) const noexcept ;
(depuis C++20)

Retourne un pointeur vers la valeur contenue dans value_ . Le comportement est indéfini si value_ ne contient pas de valeur.

Guides de déduction

template < class T >
single_view ( T ) - > single_view < T > ;
(depuis C++20)

Notes

Pour un single_view , la fonction membre héritée empty retourne toujours false , et la fonction de conversion héritée operator bool retourne toujours true .

Exemple

Exécuter ce code 
#include <iomanip>
#include <iostream>
#include <ranges>
#include <string>
#include <tuple>
int main()
{
    constexpr std::ranges::single_view sv1{3.1415}; // utilise le constructeur (const T&)
    static_assert(sv1);
    static_assert(not sv1.empty());
    std::cout << "1) *sv1.data(): " << *sv1.data() << '\n'
              << "2) *sv1.begin(): " << *sv1.begin() << '\n'
              << "3)  sv1.size(): " << sv1.size() << '\n'
              << "4)  distance: " << std::distance(sv1.begin(), sv1.end()) << '\n';
    std::string str{"C++20"};
    std::cout << "5)  str = " << std::quoted(str) << '\n';
    std::ranges::single_view sv2{std::move(str)}; // utilise le constructeur (T&&)
    std::cout << "6) *sv2.data(): " << std::quoted(*sv2.data()) << '\n'
              << "7)  str = " << std::quoted(str) << '\n';
    std::ranges::single_view<std::tuple<int, double, std::string>>
        sv3{std::in_place, 42, 3.14, "😄"}; // utilise (std::in_place_t, Args&&... args)
    std::cout << "8)  sv3 contient un tuple : { "
              << std::get<0>(sv3[0]) << ", "
              << std::get<1>(sv3[0]) << ", "
              << std::get<2>(sv3[0]) << " }\n";
}

Sortie : 

1) *sv1.data(): 3.1415
2) *sv1.begin(): 3.1415
3)  sv1.size(): 1
4)  distance: 1
5)  str = "C++20"
6) *sv2.data(): "C++20"
7)  str = ""
8)  sv3 holds a tuple: { 42, 3.14, 😄 }

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 3428 C++20 single_view était convertible depuis std::in_place_t le constructeur est rendu explicite
LWG 4035 C++20 single_view ne fournissait pas la fonction membre empty() fournit empty()
P2367R0 C++20 les guides de déduction pour single_view ne dégradaient pas l'argument ;
views::single copiait mais n'encapsulait pas un single_view 		guide de dégradation fourni ;
rendu toujours encapsulant

Voir aussi

(C++17)
un wrapper qui peut contenir ou non un objet
(modèle de classe)
(C++20)
une view vide sans éléments
(modèle de classe) (modèle de variable)
(C++20)
une view sur les sous-intervalles obtenus en divisant une autre view en utilisant un délimiteur
(modèle de classe) (objet adaptateur de plage)