std::flat_multimap<Key,T,Compare,KeyContainer,MappedContainer>:: emplace

Insère un nouvel élément dans le conteneur construit sur place avec les args donnés.

Initialise un objet t de type std:: pair < key_type, mapped_type > avec std:: forward < Args > ( args ) ... ; si la carte contient déjà un élément dont la clé est équivalente à t. first , * this reste inchangé. Sinon, équivalent à :

auto key_it = ranges::upper_bound(c.keys, t.first, compare);
auto value_it = c.values.begin() + std::distance(c.keys.begin(), key_it);
c.keys.insert(key_it, std::move(t.first));
c.values.insert(value_it, std::move(t.second));

Cette surcharge participe à la résolution de surcharge uniquement si std:: is_constructible_v < std:: pair < key_type, mapped_type > , Args... > est true .

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

Paramètres

Valeur de retour

Un itérateur vers l'élément inséré.

Exceptions

Si une exception est levée pour quelque raison que ce soit, cette fonction n'a aucun effet ( garantie forte de sécurité face aux exceptions ).

Complexité

Linéaire dans 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 <iostream>
#include <string>
#include <utility>
#include <flat_map>
int main()
{
    std::flat_multimap<std::string, std::string> m;
    // utilise le constructeur de déplacement de pair
    m.emplace(std::make_pair(std::string("a"), std::string("a")));
    // utilise le constructeur de conversion par déplacement de pair
    m.emplace(std::make_pair("b", "abcd"));
    // utilise le constructeur template de pair
    m.emplace("d", "ddd");
    // emplace avec clé dupliquée
    m.emplace("d", "DDD");
    // utilise le constructeur piecewise de pair
    m.emplace(std::piecewise_construct,
              std::forward_as_tuple("c"),
              std::forward_as_tuple(10, 'c'));
    for (const auto& p : m)
        std::cout << p.first << " => " << p.second << '\n';
}

a => a
b => abcd
c => cccccccccc
d => ddd
d => DDD

Voir aussi