std::set<Key,Compare,Allocator>:: emplace

Insère un nouvel élément dans le conteneur construit sur place avec les args donnés, s'il n'existe aucun élément avec la clé dans le conteneur.

Le constructeur du nouvel élément est appelé avec exactement les mêmes arguments que ceux fournis à emplace , transmis via std:: forward < Args > ( args ) ... . L'élément peut être construit même s'il existe déjà un élément avec la clé dans le conteneur, auquel cas le nouvel élément construit sera immédiatement détruit.

Si value_type n'est pas EmplaceConstructible dans set à partir de args , le comportement est indéfini.

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

Paramètres

Valeur de retour

Une paire constituée d'un itérateur vers l'élément inséré (ou vers l'élément qui a empêché l'insertion) et d'une bool valeur définie à true si et seulement si l'insertion a eu lieu.

Exceptions

Si une exception est levée pour quelque raison que ce soit, cette fonction n'a aucun effet ( strong exception safety guarantee ).

Complexité

Logarithmique par rapport à la taille du conteneur.

Notes

L'utilisation judicieuse de emplace permet de construire le nouvel élément tout en évitant les opérations inutiles de copie ou de déplacement.

Exemple

#include <chrono>
#include <cstddef>
#include <functional>
#include <iomanip>
#include <iostream>
#include <string>
#include <set>
class Dew
{
private:
    int a, b, c;
public:
    Dew(int _a, int _b, int _c)
        : a(_a), b(_b), c(_c)
    {}
    bool operator<(const Dew& other) const
    {
        return (a < other.a) ||
               (a == other.a && b < other.b) ||
               (a == other.a && b == other.b && c < other.c);
    }
};
constexpr int nof_operations{101};
std::size_t set_emplace()
{
    std::set<Dew> set;
    for (int i = 0; i < nof_operations; ++i)
        for (int j = 0; j < nof_operations; ++j)
            for (int k = 0; k < nof_operations; ++k)
                set.emplace(i, j, k);
    return set.size();
}
std::size_t set_insert()
{
    std::set<Dew> set;
    for (int i = 0; i < nof_operations; ++i)
        for (int j = 0; j < nof_operations; ++j)
            for (int k = 0; k < nof_operations; ++k)
                set.insert(Dew(i, j, k));
    return set.size();
}
void time_it(std::function<int()> set_test, std::string what = "")
{
    const auto start = std::chrono::system_clock::now();
    const auto the_size = set_test();
    const auto stop = std::chrono::system_clock::now();
    const std::chrono::duration<double, std::milli> time = stop - start;
    if (!what.empty() && the_size)
        std::cout << std::fixed << std::setprecision(2)
                  << time << " for " << what << '\n';
}
int main()
{
    time_it(set_insert, "cache warming...");
    time_it(set_insert, "insert");
    time_it(set_insert, "insert");
    time_it(set_emplace, "emplace");
    time_it(set_emplace, "emplace");
}

630.58ms for cache warming...
577.16ms for insert
560.84ms for insert
547.10ms for emplace
549.44ms for emplace

Voir aussi