Namespaces
Variants

    std::optional<T>::emplace

    De es.cppreference.net
     
    C++
    Soporte del compilador
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades 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 soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte del lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de la biblioteca (C++20)
    Utilidades del programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación tripartita
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
     
    std::optional
     
    template< class... Args >
T& emplace( Args&&... args );
    		(1) (desde C++17)
    (constexpr desde C++20)    		 
    template< class U, class... Args >
T& emplace( std::initializer_list<U> ilist, Args&&... args );
    		(2) (desde C++17)
    (constexpr desde C++20)

    Construye el valor contenido in-situ. Si *this ya contiene un valor antes de la llamada, el valor contenido se destruye llamando a su destructor.

    1) Inicializa el valor contenido mediante inicialización directa (pero no inicialización directa de lista) con std::forward<Args>(args)... como parámetros.
    2) Inicializa el valor contenido llamando a su constructor con ilist, std::forward<Args>(args)... como parámetros. Esta sobrecarga participa en la resolución de sobrecarga solo si std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value es true.

    Parámetros

    args... - los argumentos a pasar al constructor
    ilist - la lista de inicializadores a pasar al constructor
    Requisitos de tipo
    -
    T debe ser construible desde Args... para la sobrecarga (1)
    -
    T debe ser construible desde std::initializer_list y Args... para la sobrecarga (2)

    Valor de retorno

    Una referencia al nuevo valor contenido.

    Excepciones

    Cualquier excepción lanzada por el constructor seleccionado de T . Si se lanza una excepción, * this no contiene un valor después de esta llamada (el valor contenido previamente, si existía, ha sido destruido).

    Macro de prueba de características Valor Std Característica
    __cpp_lib_optional 202106L (C++20)
    (DR20)     		Completamente constexpr ( 1,2 )

    Ejemplo

    Ejecutar este código 
    #include <iostream>
#include <optional>
struct A
{
    std::string s;
    A(std::string str) : s(std::move(str)), id{n++} { note("+ constructed"); }
    ~A() { note("~ destructed"); }
    A(const A& o) : s(o.s), id{n++} { note("+ copy constructed"); }
    A(A&& o) : s(std::move(o.s)), id{n++} { note("+ move constructed"); }
    A& operator=(const A& other)
    {
        s = other.s;
        note("= copy assigned");
        return *this;
    }
    A& operator=(A&& other)
    {
        s = std::move(other.s);
        note("= move assigned");
        return *this;
    }
    inline static int n{};
    int id{};
    void note(auto s) { std::cout << "  " << s << " #" << id << '\n'; }
};
int main()
{
    std::optional<A> opt;
    std::cout << "Assign:\n";
    opt = A("Lorem ipsum dolor sit amet, consectetur adipiscing elit nec.");
    std::cout << "Emplace:\n";
    // Como opt contiene un valor, también destruirá ese valor
    opt.emplace("Lorem ipsum dolor sit amet, consectetur efficitur.");
    std::cout << "Fin del ejemplo\n";
}

    Salida: 

    Assign:
  + constructed #0
  + move constructed #1
  ~ destructed #0
Emplace:
  ~ destructed #1
  + constructed #2
Fin del ejemplo
  ~ destructed #2

    Informes de defectos

    Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

    DR Aplicado a Comportamiento publicado Comportamiento correcto
    P2231R1 C++20 emplace no era constexpr mientras que las operaciones requeridas pueden ser constexpr en C++20 convertido en constexpr

    Véase también

    		asigna contenidos
    (función miembro pública)