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

Défini dans l'en-tête `<ranges>`
template< std::copy_constructible T > requires std::is_object_v<T> class single_view : public ranges::view_interface<single_view<T>>	(1)	(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>>	(1)		(depuis C++23)
namespace views { inline constexpr /* unspecified / single = / unspecified */; }	(2)	(depuis C++20)
Signature d'appel
template< class T > requires /* see below / constexpr / see below */ single( T&& t );		(depuis C++20)

1) Produit une vue qui contient exactement un élément d'une valeur spécifiée.

2) L'expression views::single(e) est équivalente à une 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 à la single_view parente. Copier single_view crée une copie de l'élément.

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 Description

`copyable-box` `<T>`	(jusqu'à C++23)
`movable-box` `<T>`	(depuis C++23)

value_

le seul élément de la vue
(objet membre d'exposition uniquement*)

Fonctions membres

(constructor)	construit un `single_view` (fonction membre publique)
begin	retourne un pointeur vers l'élément (fonction membre publique)
end	retourne un pointeur après l'élément (fonction membre publique)
empty [static]	retourne false (fonction membre statique publique)
size [static]	retourne 1 (fonction membre statique publique)
data	retourne un pointeur vers l'élément (fonction membre publique)
Hérité de ranges::view_interface
cbegin (C++23)	renvoie un itérateur constant vers le début de la plage (fonction membre publique de `std::ranges::view_interface<D>`)
cend (C++23)	renvoie un sentinelle pour l'itérateur constant de la plage (fonction membre publique de `std::ranges::view_interface<D>`)
operator bool	renvoie si la vue dérivée n'est pas vide, à condition que ranges::empty lui soit applicable (fonction membre publique de `std::ranges::view_interface<D>`)
front	renvoie le premier élément dans la vue dérivée, à condition qu'elle satisfasse `forward_range` (fonction membre publique de `std::ranges::view_interface<D>`)
back	renvoie le dernier élément dans la vue dérivée, à condition qu'elle satisfasse `bidirectional_range` et `common_range` (fonction membre publique de `std::ranges::view_interface<D>`)
operator[]	renvoie le `n`^e élément dans la vue dérivée, à condition qu'elle satisfasse `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

optional (C++17)	un wrapper qui peut contenir ou non un objet (modèle de classe)
ranges::empty_view views::empty (C++20)	une `view` vide sans éléments (modèle de classe) (modèle de variable)
ranges::split_view views::split (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)

Support du compilateur
Libre et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque des concepts (C++20)
Bibliothèque de diagnostic
Bibliothèque de gestion mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque des conteneurs
Bibliothèque des itérateurs
Bibliothèque des plages (ranges) (C++20)
Bibliothèque des algorithmes
Bibliothèque des chaînes de caractères
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque du système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants