std::list<T,Allocator>:: emplace

Inserta un nuevo elemento en el contenedor directamente antes de pos .

El elemento se construye mediante std::allocator_traits::construct , que utiliza placement new para construir el elemento in-situ en una ubicación proporcionada por el contenedor.

Los argumentos args... se reenvían al constructor como std:: forward < Args > ( args ) ... . args... pueden hacer referencia directa o indirectamente a un valor en el contenedor.

No se invalidan iteradores ni referencias.

Parámetros

Valor de retorno

Iterador que apunta al elemento emplazado.

Complejidad

Constante.

Excepciones

Si se lanza una excepción (por ejemplo, por el constructor), el contenedor permanece sin modificar, como si esta función nunca hubiera sido llamada (garantía fuerte de excepción).

Ejemplo

#include <iostream>
#include <string>
#include <list>
struct A
{
    std::string s;
    A(std::string str) : s(std::move(str)) { std::cout << " constructed\n"; }
    A(const A& o) : s(o.s) { std::cout << " copy constructed\n"; }
    A(A&& o) : s(std::move(o.s)) { std::cout << " move constructed\n"; }
    A& operator=(const A& other)
    {
        s = other.s;
        std::cout << " copy assigned\n";
        return *this;
    }
    A& operator=(A&& other)
    {
        s = std::move(other.s);
        std::cout << " move assigned\n";
        return *this;
    }
};
int main()
{
    std::list<A> container;
    std::cout << "construct 2 times A:\n";
    A two{"two"};
    A three{"three"};
    std::cout << "emplace:\n";
    container.emplace(container.end(), "one");
    std::cout << "emplace with A&:\n";
    container.emplace(container.end(), two);
    std::cout << "emplace with A&&:\n";
    container.emplace(container.end(), std::move(three));
    std::cout << "content:\n";
    for (const auto& obj : container)
        std::cout << ' ' << obj.s;
    std::cout << '\n';
}

construct 2 times A:
 constructed
 constructed
emplace:
 constructed
emplace with A&:
 copy constructed
emplace with A&&:
 move constructed
content:
 one two three

Informes de defectos

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

Véase también