std::deque<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.

Tous les itérateurs (y compris l'itérateur end() ) sont invalidés. Les références sont également invalidées, sauf si pos == begin() ou pos == end() , auquel cas elles ne sont pas invalidées.

Paramètres

Valeur de retour

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

Complexité

Linéaire dans la plus petite des distances entre pos et l'une ou l'autre des extrémités du conteneur.

Exceptions

Si une exception est lancée autrement que par le constructeur de copie, le constructeur de déplacement, l'opérateur d'affectation, ou l'opérateur d'affectation de déplacement du T , ou si une exception est lancée pendant que emplace est utilisé pour insérer un seul élément à l'une ou l'autre extrémité, 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 <deque>
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::deque<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