std:: variant

Die Klassenvorlage std::variant repräsentiert eine typsichere Union .

Eine Instanz von variant enthält zu jedem gegebenen Zeitpunkt entweder einen Wert eines ihrer alternativen Typen, oder im Fehlerfall - keinen Wert (dieser Zustand ist schwer zu erreichen, siehe valueless_by_exception ).

Wie bei Unions gilt: Wenn ein Variant einen Wert eines Objekttyps T enthält, ist das T -Objekt innerhalb des variant -Objekts verschachtelt.

Ein Variant darf keine Referenzen, Arrays oder den Typ void enthalten.

Ein Variant darf denselben Typ mehr als einmal halten und unterschiedlich cv-qualifizierte Versionen desselben Typs halten.

In Übereinstimmung mit dem Verhalten von Unions während der Aggregatinitialisierung hält ein standardmäßig konstruierter Variant einen Wert seiner ersten Alternative, es sei denn, diese Alternative ist nicht standardmäßig konstruierbar (in diesem Fall ist der Variant ebenfalls nicht standardmäßig konstruierbar). Die Hilfsklasse std::monostate kann verwendet werden, um solche Variants standardmäßig konstruierbar zu machen.

Ein Programm, das die Definition von std::variant ohne Template-Argumente instanziiert, ist fehlerhaft. std :: variant < std:: monostate > kann stattdessen verwendet werden.

Wenn ein Programm eine explizite oder partielle Spezialisierung von std::variant deklariert, ist das Programm fehlerhaft, keine Diagnose erforderlich.

Template-Parameter

Memberfunktionen

Nicht-Member-Funktionen

Hilfsklassen

Hilfsobjekte

Hinweise

Beispiel

#include <cassert>
#include <iostream>
#include <string>
#include <variant>
int main()
{
    std::variant<int, float> v, w;
    v = 42; // v enthält int
    int i = std::get<int>(v);
    assert(42 == i); // erfolgreich
    w = std::get<int>(v);
    w = std::get<0>(v); // gleiche Wirkung wie die vorherige Zeile
    w = v; // gleiche Wirkung wie die vorherige Zeile
//  std::get<double>(v); // Fehler: kein double in [int, float]
//  std::get<3>(v);      // Fehler: gültige Indexwerte sind 0 und 1
    try
    {
        std::get<float>(w); // w enthält int, nicht float: wird werfen
    }
    catch (const std::bad_variant_access& ex)
    {
        std::cout << ex.what() << '\n';
    }
    using namespace std::literals;
    std::variant<std::string> x("abc");
    // konvertierende Konstruktoren funktionieren, wenn eindeutig
    x = "def"; // konvertierende Zuweisung funktioniert ebenfalls, wenn eindeutig
    std::variant<std::string, void const*> y("abc");
    // wandelt in void const* um, wenn ein char const* übergeben wird
    assert(std::holds_alternative<void const*>(y)); // erfolgreich
    y = "xyz"s;
    assert(std::holds_alternative<std::string>(y)); // erfolgreich
}

std::get: wrong index for variant

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch