std::list<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 le placement new pour construire l'élément in-situ à un emplacement fourni par le conteneur.

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.

Aucun itérateur ou référence n'est invalidé.

Paramètres

Valeur de retour

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

Complexité

Constante.

Exceptions

Si une exception est levée (par exemple par le constructeur), le conteneur reste inchangé, comme si cette fonction n'avait jamais été appelée (garantie d'exception forte).

Exemple

#include <iostream>
#include <string>
#include <list>
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::list<A> container;
    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