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

Inserta un nuevo elemento en el contenedor construido in-situ con los args dados.

El constructor del nuevo elemento es llamado exactamente con los mismos argumentos suministrados a emplace , reenviados mediante std:: forward < Args > ( args ) ... .

Si value_type no es EmplaceConstructible en multiset desde args , el comportamiento es indefinido.

No se invalidan iteradores ni referencias.

Parámetros

Valor de retorno

Un iterador al elemento insertado.

Excepciones

Si se lanza una excepción por cualquier razón, esta función no tiene efecto ( strong exception safety guarantee ).

Complejidad

Logarítmico en el tamaño del contenedor.

Notas

El uso cuidadoso de emplace permite construir el nuevo elemento evitando operaciones innecesarias de copia o movimiento.

Ejemplo

#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::multiset<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::multiset<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");
}

499.61ms for cache warming...
447.89ms for insert
436.77ms for insert
430.62ms for emplace
428.61ms for emplace

Véase también