Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::vector::emplace_back — construir un elemento al final del vector

Construye un elemento al final del vector a partir de los argumentos recibidos. Aprende qué devuelve la función y cuándo se invalidan las referencias existentes.

Versión: ISO C++23; implementation support may vary

Sintaxis

#include <vector>

// Member declaration inside std::vector<T, Allocator> (C++23):
template<class... Args>
constexpr reference emplace_back(Args&&... args);

// Call on a vector v:
v.emplace_back(args...);

std::vector::emplace_back, declarado en <vector>, añade un elemento al final del vector y aumenta size() en uno si la llamada tiene éxito. Los parámetros Args&&... son referencias de reenvío: std::forward conserva la distinción entre lvalue y rvalue, pero reenvía un prvalue como xvalue. En la plantilla primaria, el elemento de tipo T se construye directamente en el almacenamiento del vector mediante una llamada a std::allocator_traits<Allocator>::construct con los argumentos reenviados. T debe cumplir EmplaceConstructible para esos argumentos y MoveInsertable para ese vector, incluso si ya hay capacidad suficiente. La especialización std::vector<bool> no está obligada a usar allocator_traits::construct para construir sus valores.

emplace_back puede usar un constructor explicit sin que quien llama cree un T temporal. Si ya tienes un T, push_back expresa claramente la intención de copiarlo (const T&) o pasarlo para moverlo (T&&). Construir en el sitio no garantiza que no haya copias ni movimientos. En C++11 y C++14 devolvía void; desde C++17 devuelve una reference al nuevo elemento (T& en la plantilla primaria, un objeto proxy en std::vector<bool>). Es constexpr desde C++20, con sujeción a las reglas de evaluación constante.

Añadir al final cuesta tiempo constante amortizado; una llamada que reasigna memoria cuesta tiempo lineal en el número de elementos. Si el nuevo tamaño supera la capacity() anterior, la reasignación invalida todos los punteros, referencias e iteradores existentes a elementos, además del antiguo end(). Sin reasignación solo se invalida el antiguo end(). Si reserve(n) tiene éxito, garantiza una capacidad de al menos n, pero no modifica size() ni crea elementos.

Si la inserción lanza una excepción, normalmente el vector queda intacto. Sin embargo, si la excepción procede del constructor de movimiento de un T que no cumple CopyInsertable para ese vector, los efectos no están especificados. No accedas a elementos mediante referencias o punteros invalidados.

Ejemplos

#include <iostream>
#include <string>
#include <utility>
#include <vector>

struct Result {
    std::string name;
    int score;

    explicit Result(std::string n, int s) : name(std::move(n)), score(s) {}
};

int main() {
    std::vector<Result> results;
    results.reserve(2);
    std::cout << "size after reserve: " << results.size() << '\n';

    auto& first = results.emplace_back("Ada", 40);
    results.emplace_back("Lin", 35);
    first.score += 2;

    std::cout << "size after insertion: " << results.size() << '\n';
    for (const auto& result : results) {
        std::cout << result.name << ": " << result.score << '\n';
    }
}

Resultado

size after reserve: 0
size after insertion: 2
Ada: 42
Lin: 35

`reserve(2)` no crea elementos, pero garantiza que ninguna de las dos inserciones reasigne memoria. Por eso `first` sigue haciendo referencia al primer resultado y, al modificarlo, la puntuación de Ada pasa de 40 a 42.

Lecciones relacionadas

  • C++ · Lección 18 · Avanzado · Versión: 3
  • C++ · Lección 32 · Avanzado · Versión: 3
  • C++ · Lección 36 · Avanzado · Versión: 3

Fuentes