variant (Clase)

Cualquier instancia de variant en un momento dado contiene un valor de uno de sus tipos alternativos o no contiene ningún valor.

Sintaxis

template <class... Types>
    class variant

Miembros

Constructores

Nombre Descripción
variant Construye un objeto de tipo variant.

Funciones

NOMBRE Descripción
emplace Crea un nuevo valor contenido.
índice Devuelve el índice de un valor contenido.
swap
valueless_by_exception Devuelve false si la variante contiene un valor.

Operadores

NOMBRE Descripción
operator= Reemplaza la variante por una copia de otra variante.

emplace

Crea un nuevo valor contenido.

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&&...);

Índice

Devuelve el índice de un valor contenido.

constexpr size_t index() const noexcept;

Variante

Construye un objeto de tipo variant. También incluye un destructor.

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();

Parámetros

Al
La clase de asignador que se usa con este objeto.

operator=

Reemplaza la variante por una copia de otra variante.

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

Intercambio

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

valueless_by_exception

Devuelve false si la variante contiene un valor.

constexpr bool valueless_by_exception() const noexcept;