std::variant<Types...>::emplace

 

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

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Macros de prueba de característica de la biblioteca (C++20) Servicios de programa Funciones variádicas initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Apoyo de corrutinas (C++20) Apoyo de contratos (C++26) Comparación de tres vías (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::variant

Funciones miembro

variant::variant

variant::~variant

variant::operator=

Observadores

variant::index

variant::valueless_by_exception

Modificadores

variant::emplace

variant::swap

Funciones no miembro

visit

holds_alternative

get

get_if

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)

swap

Clases auxiliares

monostate

bad_variant_access

variant_size

variant_alternative

hash

Objetos auxiliares

variant_npos

 

template <class T, class... Args> T& emplace(Args&&... args);	(1)	(desde C++17)
template <class T, class U, class... Args> T& emplace( std::initializer_list<U> il, Args&&... args );	(2)	(desde C++17)
template <size_t I, class... Args> std::variant_alternative_t<I, variant>& emplace( Args&&... args );	(3)	(desde C++17)
template <size_t I, class U, class... Args> std::variant_alternative_t<I, variant>& emplace( std::initializer_list<U> il, Args&&... args );	(4)	(desde C++17)

Crea un nuevo valor en el lugar, en un objeto variante existente.

1) Equivalente a emplace<I>(std::forward<Args>(args)...), donde I es el subíndice basado en cero de T en Types.... Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_constructible_v<T, Args...> es true, y T ocurre exactamente una vez en Types....

2) Equivalente a emplace<I>(il, std::forward<Args>(args)...), donde I es el subíndice basado en cero de T en Types.... Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_constructible_v<T, std::initializer_list<U>&, Args...> es true, y T ocurre exactamente una vez Types....

3) Primero destruye el valor contenido actualmente en (si es que lo hay). Luego inicializa directamente el valor contenido como si se construyera un valor de tipo T_I con los argumentos std::forward<Args>(args).... Si se lanza una excepción, *this puede volverse valueless_by_exception. Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_constructible_v<T_I, Args...> es true. El comportamiento está indefinido si I no es menor que sizeof...(Types).

4) Primero destruye el valor contenido actualmente en (si es que lo hay). Luego inicializa directamente el valor contenido como si se construyera un valor de tipo T_I con los argumentos il, std::forward<Args>(args).... Si se lanza una excepción, *this puede volverse valueless_by_exception. Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_constructible_v<T_I, initializer_list<U>&, Args...> es true. El comportamiento está indefinido si I no es menor que sizeof...(Types).

Parámetros

args	-	Los argumentos del constructor a usar al construir el nuevo valor.
il	-	Argumento de tipo std::initializer_list a usar al construir el nuevo valor.

Valor de retorno

Una referencia al nuevo valor contenido.

Excepciones

1-4) Cualquier excepción lanzada durante la inicialización del valor contenido.

Ejemplo

Ejecuta este código

#include <iostream>
#include <string>
#include <variant>

int main()
{
  std::variant<std::string> v1;
  v1.emplace<0>("abc");           // de acuerdo
  std::cout << std::get<0>(v1) << '\n';
  v1.emplace<std::string>("def"); // de acuerdo
  std::cout << std::get<0>(v1) << '\n';

  std::variant<std::string, std::string> v2;
  v2.emplace<1>("ghi");           // de acuerdo
  std::cout << std::get<1>(v2) << '\n';
  // v2.emplace<std::string>("abc"); -> ERROR
}

Salida:

abc
def
ghi

Véase también

operator=

Asigna un variante. (función miembro pública)