Clases
(C++17) |
Una unión discriminada con seguridad de tipo. (plantilla de clase) |
(C++17) |
Tipo de marcador de posición para usarse como la primer alternativa en un variante de tipos no construibles por defecto. (clase) |
(C++17) |
Excepción lanzada durante accesos inválidos al valor de un variante. (clase) |
(C++17) |
Obtiene el tamaño de la lista de alternativas del variante en tiempo de compilación. (plantilla de clase) (plantilla de variables) |
| Obtiene el tipo de la alternativa dado su subíndice, en tiempo de compilación. (plantilla de clase) (plantilla de alias) | |
(C++17) |
Especializa el algoritmo std::hash. (especialización de plantilla de clase) |
Asistentes
(C++17) |
Subíndice del variante en el estado inválido. (constante) |
Funciones
(C++17) |
Llama al objeto función proporcionado con los argumentos mantenidos por uno o más variantes. (plantilla de función) |
(C++17) |
Comprueba si el variante actualmente mantiene un tipo dado. (plantilla de función) |
(C++17) |
Lee el valor del variante dado el subíndice o el tipo (si el tipo es único), lanza una excepción si existe un error. (plantilla de función) |
(C++17) |
Obtiene un puntero al valor de un variante al que se apunta dado el subíndice del tipo (si es único), devuelve nulo cuando existe un error. (plantilla de función) |
(C++17)(C++17)(C++17)(C++17)(C++17)(C++17)(C++20) |
Compara objetos variant con sus valores contenidos. (plantilla de función) |
(C++17) |
Especializa el algoritmo std::swap. (función) |
Sinopsis
namespace std {
// variante
template<typename... Types> class variant;
// clases asistentes para variante
template<typename T> struct variant_size; // no definida
template<typename T> struct variant_size<const T>;
template<typename T> struct variant_size<volatile T>;
template<typename T> struct variant_size<const volatile T>;
template<typename T> inline constexpr size_t variant_size_v = variant_size<T>::value;
template<typename... Types>
struct variant_size<variant<Types...>>;
template <size_t I, typename T> struct variant_alternative; // no definida
template <size_t I, typename T> struct variant_alternative<I, const T>;
template <size_t I, typename T> struct variant_alternative<I, volatile T>;
template <size_t I, typename T> struct variant_alternative<I, const volatile T>;
template <size_t I, typename T>
using variant_alternative_t = typename variant_alternative<I, T>::type;
template <size_t I, typename... Types>
struct variant_alternative<I, variant<Types...>>;
inline constexpr size_t variant_npos = -1;
// acceso a valor
template<typename T, typename... Types>
constexpr bool holds_alternative(const variant<Types...>&) noexcept;
template <size_t I, typename... Types>
constexpr variant_alternative_t<I, variant<Types...>>&
get(variant<Types...>&);
template <size_t I, typename... Types>
constexpr variant_alternative_t<I, variant<Types...>>&&
get(variant<Types...>&&);
template <size_t I, typename... Types>
constexpr const variant_alternative_t<I, variant<Types...>>&
get(const variant<Types...>&);
template <size_t I, typename... Types>
constexpr const variant_alternative_t<I, variant<Types...>>&&
get(const variant<Types...>&&);
template<typename T, typename... Types>
constexpr T& get(variant<Types...>&);
template<typename T, typename... Types>
constexpr T&& get(variant<Types...>&&);
template<typename T, typename... Types>
constexpr const T& get(const variant<Types...>&);
template<typename T, typename... Types>
constexpr const T&& get(const variant<Types...>&&);
template <size_t I, typename... Types>
constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
get_if(variant<Types...>*) noexcept;
template <size_t I, typename... Types>
constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
get_if(const variant<Types...>*) noexcept;
template<typename T, typename... Types>
constexpr add_pointer_t<T> get_if(variant<Types...>*) noexcept;
template<typename T, typename... Types>
constexpr add_pointer_t<const T> get_if(const variant<Types...>*) noexcept;
// operadores relacionales
template<typename... Types>
constexpr bool operator==(const variant<Types...>&,
const variant<Types...>&);
template<typename... Types>
constexpr bool operator!=(const variant<Types...>&,
const variant<Types...>&);
template<typename... Types>
constexpr bool operator<(const variant<Types...>&,
const variant<Types...>&);
template<typename... Types>
constexpr bool operator>(const variant<Types...>&,
const variant<Types...>&);
template<typename... Types>
constexpr bool operator<=(const variant<Types...>&,
const variant<Types...>&);
template<typename... Types>
constexpr bool operator>=(const variant<Types...>&,
const variant<Types...>&);
// visitación
template<typename Visitor, typename... Variants>
constexpr /*véase definición*/ visit(Visitor&&, Variants&&...);
// clase monostate
struct monostate;
// operadores relacionales de monostate
constexpr bool operator<(monostate, monostate) noexcept;
constexpr bool operator>(monostate, monostate) noexcept;
constexpr bool operator<=(monostate, monostate) noexcept;
constexpr bool operator>=(monostate, monostate) noexcept;
constexpr bool operator==(monostate, monostate) noexcept;
constexpr bool operator!=(monostate, monostate) noexcept;
// algoritmos especializados
template<typename... Types>
void swap(variant<Types...>&, variant<Types...>&) noexcept(/*véase definición*/);
// clase bad_variant_access
class bad_variant_access;
// soporte para hash
template<typename T> struct hash;
template<typename... Types> struct hash<variant<Types...>>;
template <> struct hash<monostate>;
}
Plantilla de clase std::variant
template<typename... Types>
class variant {
public:
// constructores
constexpr variant() noexcept(/*véase definición*/);
variant(const variant&);
variant(variant&&) noexcept(/*véase definición*/);
template<typename T> constexpr variant(T&&) noexcept(/*véase definición*/);
template<typename T, typename... Args>
constexpr explicit variant(in_place_type_t<T>, Args&&...);
template<typename T, typename U, typename... Args>
constexpr explicit variant(in_place_type_t<T>, initializer_list<U>, Args&&...);
template <size_t I, typename... Args>
constexpr explicit variant(in_place_index_t<I>, Args&&...);
template <size_t I, typename U, typename... Args>
constexpr explicit variant(in_place_index_t<I>, initializer_list<U>, Args&&...);
// destructor
~variant();
// asignación
variant& operator=(const variant&);
variant& operator=(variant&&) noexcept(/*véase definición*/);
template<typename T> variant& operator=(T&&) noexcept(/*véase definición*/);
// modificadores
template<typename T, typename... Args> void emplace(Args&&...);
template<typename T, typename U, typename... Args>
void emplace(initializer_list<U>, Args&&...);
template <size_t I, typename... Args> void emplace(Args&&...);
template <size_t I, typename U, typename... Args>
void emplace(initializer_list<U>, Args&&...);
// estatus del valor
constexpr bool valueless_by_exception() const noexcept;
constexpr size_t index() const noexcept;
// intercambio
void swap(variant&) noexcept(/*véase definición*/);
};
Clase std::monostate
struct monostate{};
Clase std::bad_variant_access
class bad_variant_access : public exception {
public:
bad_variant_access() noexcept;
virtual const char* what() const noexcept;
};