CKTIS / C++
std::vector::emplace_back — costruire un elemento in coda al vettore
Costruisce un elemento in coda al vettore a partire dagli argomenti ricevuti. Scopri cosa restituisce la funzione e quando i riferimenti esistenti diventano invalidi.
Versione: ISO C++23; implementation support may vary
Sintassi
#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, dichiarato in <vector>, aggiunge un elemento in coda al vettore e, in caso di successo, incrementa size() di uno. I parametri Args&&... sono riferimenti di inoltro: std::forward conserva la distinzione tra lvalue e rvalue, ma inoltra un prvalue come xvalue. Nel template primario, l’elemento di tipo T viene costruito direttamente nella memoria del vettore tramite una chiamata a std::allocator_traits<Allocator>::construct con gli argomenti inoltrati. T deve soddisfare EmplaceConstructible per quegli argomenti e MoveInsertable per quel vettore, anche se la capacità è già sufficiente. La specializzazione std::vector<bool> non è tenuta a usare allocator_traits::construct per costruire i propri valori.
emplace_back può usare un costruttore explicit senza che il chiamante crei un T temporaneo. Se hai già un T, push_back esprime chiaramente l’intenzione di copiarlo (const T&) o di passarlo per lo spostamento (T&&). La costruzione sul posto non garantisce l’assenza di copie o spostamenti. In C++11 e C++14 la funzione restituiva void; da C++17 restituisce una reference al nuovo elemento (T& nel template primario, un oggetto proxy in std::vector<bool>). È constexpr da C++20, nel rispetto delle regole della valutazione costante.
L’aggiunta in coda richiede tempo costante ammortizzato; con riallocazione, il tempo è lineare nel numero di elementi. Se la nuova dimensione supera la precedente capacity(), la riallocazione invalida tutti i puntatori, i riferimenti e gli iteratori esistenti agli elementi, oltre al vecchio end(). Senza riallocazione viene invalidato solo il vecchio end(). Una chiamata riuscita a reserve(n) garantisce una capacità di almeno n, ma non modifica size() né crea elementi.
Se l’inserimento lancia un’eccezione, di norma il vettore resta invariato. Se però l’eccezione proviene dal costruttore di spostamento di un T che non soddisfa CopyInsertable per quel vettore, gli effetti non sono specificati. Non accedere agli elementi tramite riferimenti o puntatori invalidati.
Esempi
#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';
}
}
Risultato
size after reserve: 0 size after insertion: 2 Ada: 42 Lin: 35
`reserve(2)` non crea elementi, ma garantisce che nessuno dei due inserimenti provochi una riallocazione. `first` continua quindi a riferirsi al primo risultato e, modificandolo, il punteggio di Ada passa da 40 a 42.
Lezioni correlate
- C++ · Lezione 18 · Avanzato · Versione: 3
- C++ · Lezione 32 · Avanzato · Versione: 3
- C++ · Lezione 36 · Avanzato · Versione: 3
Fonti
- WG21 N4950 — Working Draft, Standard for Programming Language C++ (C++23)
- C++ working draft — [vector.modifiers]
- C++ working draft — [sequence.reqmts]
- C++ working draft — [container.alloc.reqmts]
- C++ working draft — [vector.capacity]
- C++ working draft — [vector.overview]
- C++ working draft — [vector.bool.pspc]