Espacios de nombres
Variantes
Acciones

Archivo de encabezado de la biblioteca estándar <variant>

De cppreference.com
< cpp‎ | header
 
C++
Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas
 
Archivos de encabezado de la biblioteca estándar
 

Contenido

[editar] Clases

(C++17)
 Una unión discriminada con seguridad de tipo.
(plantilla de clase) [editar]
(C++17)
 Tipo de marcador de posición para usarse como la primer alternativa en un variante de tipos no construibles por defecto.
(clase) [editar]
(C++17)
 Excepción lanzada durante accesos inválidos al valor de un variante.
(clase) [editar]
(C++17)
 Obtiene el tamaño de la lista de alternativas del variante en tiempo de compilación.
(plantilla de clase) (plantilla de variables) [editar]
(C++17)
 Obtiene el tipo de la alternativa dado su subíndice, en tiempo de compilación.
(plantilla de clase) (plantilla de alias) [editar]
(C++17)
 Especializa el algoritmo std::hash.
(especialización de plantilla de clase) [editar]

[editar] Asistentes

(C++17)
 Subíndice del variante en el estado inválido.
(constante) [editar]

[editar] Funciones

(C++17)
 Llama al objeto función proporcionado con los argumentos mantenidos por uno o más variantes.
(plantilla de función) [editar]
(C++17)
 Comprueba si el variante actualmente mantiene un tipo dado.
(plantilla de función) [editar]
(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) [editar]
(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) [editar]
(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) [editar]
(C++17)
 Especializa el algoritmo std::swap.
(función) [editar]

[editar] 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>;
}

[editar] 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*/);
};

[editar] Clase std::monostate

struct monostate{};

[editar] Clase std::bad_variant_access

class bad_variant_access : public exception {
public:
  bad_variant_access() noexcept;
  virtual const char* what() const noexcept;
};
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/header/variant&oldid=43584»