std::vector<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 ya 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.

Si después de la operación el nuevo size() es mayor que la antigua capacity() ocurre una reasignación de memoria, en cuyo caso todos los iteradores (incluyendo el iterador end() ) y todas las referencias a los elementos quedan invalidados. De lo contrario, solo los iteradores y referencias anteriores al punto de inserción permanecen válidos.

Parámetros

Valor de retorno

Iterador que apunta al elemento emplazado.

Complejidad

Lineal en la distancia entre pos y end() .

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 de T , o si se lanza una excepción mientras se utiliza emplace para insertar un único elemento al final y T es CopyInsertable o nothrow move constructible, no hay efectos (garantía fuerte de excepción).

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

Ejemplo

#include <iostream>
#include <string>
#include <vector>
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::vector<A> container;
    // reserve enough place so vector does not have to resize
    container.reserve(10);
    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