std::variant<Types...>::variant

constexpr variant() noexcept(/* see below */);	(1)	(depuis C++17)
constexpr variant( const variant& other );	(2)	(depuis C++17)
constexpr variant( variant&& other ) noexcept(/* see below */);	(3)	(depuis C++17)
template< class T > constexpr variant( T&& t ) noexcept(/* see below */);	(4)	(depuis C++17)
template< class T, class... Args > constexpr explicit variant( std::in_place_type_t<T>, Args&&... args );	(5)	(depuis C++17)
template< class T, class U, class... Args > constexpr explicit variant( std::in_place_type_t<T>, std::initializer_list<U> il, Args&&... args );	(6)	(depuis C++17)
template< std::size_t I, class... Args > constexpr explicit variant( std::in_place_index_t<I>, Args&&... args );	(7)	(depuis C++17)
template< std::size_t I, class U, class... Args > constexpr explicit variant( std::in_place_index_t<I>, std::initializer_list<U> il, Args&&... args );	(8)	(depuis C++17)

Construit un nouvel objet variant.

1) Constructeur par défaut. Construit un variant contenant la valeur initialisée par défaut de la première alternative (index() vaut zéro).

Ce constructeur est constexpr si et seulement si l'initialisation par défaut du type de l'alternative T_0 satisferait aux exigences d'une constexpr function.
Cette surcharge participe à la résolution de surcharge uniquement si std::is_default_constructible_v<T_0> est true.

2) Constructeur par copie. Si other n'est pas valueless_by_exception, construit un variant contenant la même alternative que other et initialise directement la valeur contenue avec *std::get_if<other.index()>(std::addressof(other)). Sinon, initialise un variant valueless_by_exception.

Ce constructeur est défini comme supprimé sauf si std::is_copy_constructible_v<T_i> est true pour tous les T_i dans Types....
Il est trivial si std::is_trivially_copy_constructible_v<T_i> est true pour tous les T_i dans Types....

3) Constructeur par déplacement. Si other n'est pas valueless_by_exception, construit un variant contenant la même alternative que other et initialise directement la valeur contenue avec std::move(*std::get_if<other.index()>(std::addressof(other))). Sinon, initialise un variant valueless_by_exception.

Cette surcharge participe à la résolution de surcharge uniquement si std::is_move_constructible_v<T_i> est true pour tous les T_i dans Types....
Elle est triviale si std::is_trivially_move_constructible_v<T_i> est true pour tous les T_i dans Types....

4) Constructeur de conversion. Construit un variant contenant le type d'alternative T_j qui serait sélectionné par la résolution de surcharge pour l'expression F(std::forward<T>(t)) s'il existait une surcharge d'une fonction imaginaire F(T_i) pour chaque T_i dans Types..., excepté que les conversions restrictives ne sont pas considérées.

Formellement :

Une surcharge F(T_i) n'est considérée que si la déclaration T_i x[] = { std::forward<T>(t) }; est valide pour une variable inventée x.

Initialise directement la valeur contenue comme par une initialisation directe non-liste à partir de std::forward<T>(t).

Cette surcharge participe à la résolution de surcharge uniquement si
- sizeof...(Types) > 0,
- std::decay_t<T>(jusqu'à C++20)std::remove_cvref_t<T>(depuis C++20) n'est ni le même type que variant, ni une spécialisation de std::in_place_type_t, ni une spécialisation de std::in_place_index_t,
- std::is_constructible_v<T_j, T> est true,
- et l'expression F(std::forward<T>(t)) (avec F étant l'ensemble de fonctions imaginaires mentionné ci-dessus) est bien formée.
Ce constructeur est un constexpr constructeur si le constructeur sélectionné de T_j est un constructeur constexpr.

std::variant<std::string> v("abc"); // OK
std::variant<std::string, std::string> w("abc"); // ill-formed
std::variant<std::string, const char*> x("abc"); // OK, chooses const char*
std::variant<std::string, bool> y("abc"); // OK, chooses string; bool is not a candidate
std::variant<float, long, double> z = 0; // OK, holds long
                                         // float and double are not candidates

5) Construit un variant avec l'alternative spécifiée T et initialise la valeur contenue avec les arguments std::forward<Args>(args)....

Si le constructeur sélectionné de T est un constexpr constructeur, ce constructeur est aussi un constexpr constructeur.
Cette surcharge participe à la résolution de surcharge uniquement s'il y a exactement une occurrence de T dans Types... et std::is_constructible_v<T, Args...> est true.

6) Construit un variant avec l'alternative spécifiée T et initialise la valeur contenue avec les arguments il, std::forward<Args>(args)....

Si le constructeur sélectionné de T est un constexpr constructeur, ce constructeur est aussi un constexpr constructeur.
Cette surcharge participe à la résolution de surcharge uniquement s'il y a exactement une occurrence de T dans Types... et std::is_constructible_v<T, initializer_list<U>&, Args...> est true.

7) Construit un variant avec l'alternative T_i spécifiée par l'index I et initialise la valeur contenue avec les arguments std::forward<Args>(args)....

Si le constructeur sélectionné de T_i est un constexpr constructeur, ce constructeur est aussi un constexpr constructeur.
Cette surcharge participe à la résolution de surcharge uniquement si I < sizeof...(Types) et std::is_constructible_v<T_i, Args...> est true.

8) Construit un variant avec l'alternative T_i spécifiée par l'index I et initialise la valeur contenue avec les arguments il, std::forward<Args>(args)....

Si le constructeur sélectionné de T_i est un constexpr constructeur, ce constructeur est aussi un constexpr constructeur.
Cette surcharge participe à la résolution de surcharge uniquement si I < sizeof...(Types) et std::is_constructible_v<T_i, std::initializer_list<U>&, Args...> est true.

Paramètres

other	-	autre objet `variant` dont la valeur contenue doit être copiée/déplacée
t	-	valeur pour initialiser la valeur contenue
args...	-	arguments pour initialiser la valeur contenue
il	-	liste d'initialisation pour initialiser la valeur contenue

Exceptions

1) Peut lever toute exception levée par l'initialisation de la première alternative.

noexcept spécification :

noexcept ( std:: is_nothrow_default_constructible_v < T_0 > )

2) Peut lever toute exception levée par l'initialisation directe de tout

T_i

dans Types... .

3) Peut lever toute exception levée par la construction par déplacement de tout

T_i

dans Types... .

noexcept spécification :

noexcept ( ( std:: is_nothrow_move_constructible_v < Types > && ... ) )

4) Peut lever toute exception levée par l'initialisation de l'alternative sélectionnée

T_j

.

noexcept spécification :

noexcept ( std:: is_nothrow_constructible_v < T_j, T > )

5-8) Peut lever toute exception levée par l'appel au constructeur sélectionné de l'alternative choisie.

Notes

La bibliothèque STL de MSVC a initialement traité P0608R3 comme un changement pour le C++20. À partir de VS 2022 17.12, la bibliothèque STL de MSVC traite également P0608R3 comme un rapport de défaut contre le C++17.

Exemple

Exécuter ce code

#include <cassert>
#include <iostream>
#include <string>
#include <variant>
#include <vector>
using vector_t = std::vector<int>;
auto& operator<<(auto& out, const vector_t& v)
{
    out << "{ ";
    for (int e : v)
        out << e << ' ';
    return out << '}';
}
int main()
{
    // initialise la première alternative par valeur
    std::variant<int, std::string> var0;
    assert(std::holds_alternative<int>(var0) and
           var0.index() == 0 and
           std::obtenir<int>(var0) == 0);
    // initialise la première alternative avec std::string{"STR"};
    std::variant<std::string, int> var1{"STR"};
    assert(var1.index() == 0);
    std::cout << "1) " << std::obtenir<std::string>(var1) << '\n';
    // initialise la seconde alternative avec int == 42;
    std::variant<std::string, int> var2{42};
    assert(std::holds_alternative<int>(var2));
    std::cout << "2) " << std::obtenir<int>(var2) << '\n';
    // initialise la première alternative avec std::string{4, 'A'};
    std::variant<std::string, vector_t, float> var3
    {
        std::in_place_type<std::string>, 4, 'A'
    };
    assert(var3.index() == 0);
    std::cout << "3) " << std::obtenir<std::string>(var3) << '\n';
    // initialise la seconde alternative avec std::vector{1,2,3,4,5};
    std::variant<std::string, vector_t, char> var4
    {
        std::in_place_type<vector_t>, {1, 2, 3, 4, 5}
    };
    assert(var4.index() == 1);
    std::cout << "4) " << std::obtenir<vector_t>(var4) << '\n';
    // initialise la première alternative avec std::string{"ABCDE", 3};
    std::variant<std::string, vector_t, bool> var5 {std::in_place_index<0>, "ABCDE", 3};
    assert(var5.index() == 0);
    std::cout << "5) " << std::obtenir<std::string>(var5) << '\n';
    // initialise la seconde alternative avec std::vector(4, 42);
    std::variant<std::string, vector_t, char> var6 {std::in_place_index<1>, 4, 42};
    assert(std::holds_alternative<vector_t>(var6));
    std::cout << "6) " << std::obtenir<vector_t>(var6) << '\n';
}

Sortie :

1) STR
2) 42
3) AAAA
4) { 1 2 3 4 5 }
5) ABC
6) { 42 42 42 42 }

**Note:** Le contenu dans les balises `

` a été conservé tel quel car il s'agit de code/de données qui ne doivent pas être traduits selon les instructions. Seul le texte environnant (s'il y en avait) aurait été traduit en français.

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 2901	C++17	constructeurs sensibles à l'allocateur fournis mais `variant` ne peut pas supporter correctement les allocateurs	constructeurs supprimés
P0739R0	C++17	le constructeur de conversion template interagit mal avec la déduction d'arguments de template de classe	contrainte ajoutée
LWG 3024	C++17	le constructeur de copie ne participe pas à la résolution de surcharge si un type membre n'est pas copiable	défini comme supprimé à la place
P0602R4	C++17	les constructeurs de copie/déplacement peuvent ne pas être triviaux même si les constructeurs sous-jacents sont triviaux	requis pour propager la trivialité
P0608R3	C++17	le constructeur de conversion assemble aveuglément un ensemble de surcharge, conduisant à des conversions non intentionnelles	les conversions de rétrécissement et booléennes ne sont pas considérées
P1957R2	C++17	le constructeur de conversion pour bool ne permettait pas la conversion implicite	La conversion de pointeur vers bool est un rétrécissement et le constructeur de conversion n'a pas d'exception pour bool

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 de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et d'heure
Bibliothèque d'entrée/sortie
Bibliothèque de 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

Fonctions membres
variant::variant
variant::~variant
variant::operator=
Observateurs
variant::index
variant::valueless_by_exception
Modificateurs
variant::emplace
variant::swap
Visite
variant::visit (C++26)
Fonctions non membres
visit(std::variant)
holds_alternative
get(std::variant)
get_if
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)
swap(std::variant)
Classes auxiliaires
monostate
bad_variant_access
variant_size
variant_alternative
hash<std::variant>
Objets auxiliaires
variant_npos

fr.cppreference.net

Namespaces

Variants

std::variant<Types...>::variant

Sommaire

Paramètres

Exceptions

Notes

Exemple

Rapports de défauts