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

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

El elemento se construye mediante std::allocator_traits::construct , que normalmente utiliza placement new para construir el elemento in-situ en una ubicación proporcionada por el contenedor. Sin embargo, si la ubicación requerida está ocupada por un elemento existente, el elemento insertado se construye primero en otra ubicación y luego se asigna por movimiento a la ubicación requerida.

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.

Todos los iteradores (incluyendo el end() iterator) quedan invalidados. Las referencias también quedan invalidadas, a menos que pos == begin() o pos == end() , en cuyo caso no quedan invalidados.

Parámetros

Valor de retorno

Iterador que apunta al elemento emplazado.

Complejidad

Lineal en la menor de las distancias entre pos y cualquiera de los extremos del contenedor.

Excepciones

Si se lanza una excepción que no sea por el constructor de copia, constructor de movimiento, operador de asignación, u operador de asignación de movimiento del T , o si se lanza una excepción mientras se utiliza emplace para insertar un único elemento en cualquiera de los extremos, no hay efectos (garantía fuerte de excepción).

De lo contrario, los efectos no están especificados.

Ejemplo

#include <iostream>
#include <string>
#include <deque>
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::deque<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