Variant-Klasse

Artikel
10/12/2023

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;

Freigeben über