Variant-Klasse

Jede Instanz von Varianten zu einem bestimmten Zeitpunkt enthält entweder einen Wert eines seiner alternativen Typen, oder sie enthält keinen Wert.

Syntax

template <class... Types>
    class variant

Member

Konstruktoren

Name	Beschreibung
variant	Konstruiert ein Objekt vom Typ variant.

Funktionen

Name	Beschreibung
emplace	Erstellt einen neuen enthaltenen Wert.
Index	Gibt den Index eines enthaltenen Werts zurück.
swap
valueless_by_exception	Gibt zurück false , wenn die Variante einen Wert enthält.

Operatoren

Name	Beschreibung
operator=	Ersetzt die Variante durch eine Kopie einer anderen Variante.

emplace

Erstellt einen neuen enthaltenen Wert.

template <class T, class... Args>
    T& emplace(Args&&...);
template <class T, class U, class... Args>
    T& emplace(initializer_list<U>, Args&&...);
template <size_t I, class... Args>
    variant_alternative_t<I, variant<Types...>>& emplace(Args&&...);
template <size_t I, class U, class... Args>
    variant_alternative_t<I, variant<Types...>>& emplace(initializer_list<U>, Args&&...);

Index

Gibt den Index eines enthaltenen Werts zurück.

constexpr size_t index() const noexcept;

variant

Konstruiert ein Objekt vom Typ variant. Enthält auch einen Destruktor.

constexpr variant() noexcept(see below);
variant(const variant&);
variant(variant&&) noexcept(see below);
template <class T>
    constexpr variant(T&&) noexcept(see below);
template <class T, class... Args>
    constexpr explicit variant(in_place_type_t<T>, Args&&...);
template <class T, class U, class... Args>
    constexpr explicit variant(in_place_type_t<T>, initializer_list<U>, Args&&...);
template <size_t I, class... Args>
    constexpr explicit variant(in_place_index_t<I>, Args&&...);
template <size_t I, class U, class... Args>
    constexpr explicit variant(in_place_index_t<I>, initializer_list<U>, Args&&...);

template <class Alloc>
    variant(allocator_arg_t, const Al&);
template <class Alloc>
    variant(allocator_arg_t, const Al&, const variant&);
template <class Alloc>
    variant(allocator_arg_t, const Al&, variant&&);
template <class Alloc, class T>
    variant(allocator_arg_t, const Al&, T&&);
template <class Alloc, class T, class... Args>
    variant(allocator_arg_t, const Al&, in_place_type_t<T>, Args&&...);
template <class Alloc, class T, class U, class... Args>
    variant(allocator_arg_t, const Al&, in_place_type_t<T>, initializer_list<U>, Args&&...);
template <class Alloc, size_t I, class... Args>
    variant(allocator_arg_t, const Al&, in_place_index_t<I>, Args&&...);
template <class Alloc, size_t I, class U, class... Args>
    variant(allocator_arg_t, const Al&, in_place_index_t<I>, initializer_list<U>, Args&&...);

~variant();

Parameter

Al
Die mit diesem Objekt zu verwendende Zuweisungsklasse.

operator =

Ersetzt die Variante durch eine Kopie einer anderen Variante.

variant& operator=(const variant&);
variant& operator=(variant&&) noexcept(see below);
template <class T>
    variant& operator=(T&&) noexcept(see below);

swap

void swap(variant&) noexcept(see below);

valueless_by_exception

Gibt zurück false , wenn die Variante einen Wert enthält.

constexpr bool valueless_by_exception() const noexcept;