Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::vector::emplace_back — construire un élément en fin de vecteur

Construit un élément en fin de vecteur à partir de ses arguments. Découvrez ce que renvoie la fonction et quand l’ajout invalide les références existantes.

Version : ISO C++23; implementation support may vary

Syntaxe

#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, déclaré dans <vector>, ajoute un élément en fin de vecteur et augmente size() de un en cas de succès. Les paramètres Args&&... sont des références de transmission : std::forward préserve la distinction entre lvalue et rvalue, mais transmet une prvalue sous forme de xvalue. Dans le modèle primaire, l’élément de type T est construit directement dans la mémoire du vecteur par un appel à std::allocator_traits<Allocator>::construct avec les arguments ainsi transmis. T doit satisfaire EmplaceConstructible pour ces arguments et MoveInsertable pour ce vecteur, même si la capacité est déjà suffisante. La spécialisation std::vector<bool> n’est pas tenue d’utiliser allocator_traits::construct pour construire ses valeurs.

emplace_back peut appeler un constructeur explicit sans que l’appelant crée de T temporaire. Si vous avez déjà un T, push_back exprime clairement l’intention de le copier (const T&) ou de le passer pour un déplacement (T&&). La construction sur place ne garantit pas l’absence de copies ni de déplacements. En C++11 et C++14, la fonction renvoyait void ; depuis C++17, elle renvoie une reference au nouvel élément (T& dans le modèle primaire, un objet proxy dans std::vector<bool>). Elle est constexpr depuis C++20, sous réserve des règles de l’évaluation constante.

L’ajout en fin prend un temps constant amorti ; avec réallocation, le temps est linéaire en nombre d’éléments. Si la nouvelle taille dépasse l’ancienne capacity(), la réallocation invalide tous les pointeurs, références et itérateurs vers les éléments, ainsi que l’ancien end(). Sans réallocation, seul l’ancien end() est invalidé. Un appel réussi à reserve(n) garantit une capacité d’au moins n, sans modifier size() ni créer d’éléments.

Si l’insertion lève une exception, le vecteur reste normalement inchangé. Toutefois, si l’exception provient du constructeur de déplacement d’un T qui ne satisfait pas CopyInsertable pour ce vecteur, les effets ne sont pas spécifiés. N’accédez pas aux éléments par des références ou pointeurs invalidés.

Exemples

#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';
    }
}

Résultat

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

`reserve(2)` ne crée aucun élément, mais évite toute réallocation lors des deux insertions. `first` désigne donc toujours le premier résultat, et sa modification fait passer le score d’Ada de 40 à 42.

Leçons associées

  • C++ · Leçon 18 · Avancé · Version : 3
  • C++ · Leçon 32 · Avancé · Version : 3
  • C++ · Leçon 36 · Avancé · Version : 3

Sources