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

Insère un nouvel élément dans le conteneur directement avant pos .

L'élément est construit via std::allocator_traits::construct , qui utilise généralement le placement new pour construire l'élément in-situ à un emplacement fourni par le conteneur. Cependant, si l'emplacement requis est déjà occupé par un élément existant, l'élément inséré est d'abord construit à un autre emplacement, puis déplacé par assignation vers l'emplacement requis.

Les arguments args... sont transmis au constructeur sous la forme std:: forward < Args > ( args ) ... . args... peuvent faire référence directement ou indirectement à une valeur dans le conteneur.

Si après l'opération la nouvelle size() est supérieure à l'ancienne capacity() , une réallocation se produit, auquel cas tous les itérateurs (y compris l'itérateur end() ) et toutes les références aux éléments sont invalidés. Sinon, seuls les itérateurs et références avant le point d'insertion restent valides.

Paramètres

Valeur de retour

Itérateur pointant vers l'élément inséré.

Complexité

Linéaire dans la distance entre pos et end() .

Exceptions

Si une exception est levée autrement que par le constructeur de copie, le constructeur de déplacement, l'opérateur d'affectation ou l'opérateur de déplacement de T , ou si une exception est levée pendant que emplace est utilisé pour insérer un seul élément à la fin et que T est soit CopyInsertable ou nothrow constructible par déplacement, il n'y a aucun effet (garantie d'exception forte).

Sinon, les effets ne sont pas spécifiés.

Exemple

#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;
    // réserver assez de place pour que le vecteur n'ait pas à redimensionner
    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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi