std::variant

template< class... Types >
class variant;

Le modèle de classe std::variant représente une union sécurisée par type.

Une instance de variant détient à tout moment soit une valeur de l'un de ses types alternatifs, soit, en cas d'erreur, aucune valeur (cet état est difficile à atteindre, voir valueless_by_exception).

Comme pour les unions, si une variante détient une valeur d'un type objet T, l'objet T est imbriqué dans l'objet variant.

Une variante ne peut pas contenir de références, de tableaux ou le type void.

Une variante peut contenir plusieurs fois le même type, ainsi que des versions du même type avec des qualifications cv différentes.

Conformément au comportement des unions lors de l'initialisation d'agrégat, une variante construite par défaut détient une valeur de sa première alternative, sauf si cette alternative n'est pas constructible par défaut (auquel cas la variante n'est pas non plus constructible par défaut). La classe auxiliaire std::monostate peut être utilisée pour rendre ces variantes constructibles par défaut.

Un programme qui instancie la définition de std::variant sans arguments de modèle est mal formé. std::variant<std::monostate> peut être utilisé à la place.

Si un programme déclare une spécialisation explicite ou partielle de std::variant, le programme est mal formé, aucun diagnostic requis.

Paramètres du modèle

Fonctions membres

Fonctions non membres

Classes d'assistance

Objets auxiliaires

Notes

Exemple

#include <cassert>
#include <iostream>
#include <string>
#include <variant>
int main()
{
    std::variant<int, float> v, w;
    v = 42; // v contient int
    int i = std::get<int>(v);
    assert(42 == i); // réussit
    w = std::get<int>(v);
    w = std::get<0>(v); // même effet que la ligne précédente
    w = v; // même effet que la ligne précédente
//  std::get<double>(v); // erreur : pas de double dans [int, float]
//  std::get<3>(v);      // erreur : les valeurs d'index valides sont 0 et 1
    try
    {
        std::get<float>(w); // w contient int, pas float : va lancer une exception
    }
    catch (const std::bad_variant_access& ex)
    {
        std::cout << ex.what() << '\n';
    }
    using namespace std::literals;
    std::variant<std::string> x("abc");
    // les constructeurs de conversion fonctionnent quand ils sont non ambigus
    x = "def"; // l'affectation par conversion fonctionne aussi quand elle est non ambiguë
    std::variant<std::string, void const*> y("abc");
    // convertit en void const* quand on passe un char const*
    assert(std::holds_alternative<void const*>(y)); // réussit
    y = "xyz"s;
    assert(std::holds_alternative<std::string>(y)); // réussit
}

std::get: wrong index for variant

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.

Voir aussi