map::insert

Článek
06/09/2015

Vloží do mapování elementu nebo rozsahu prvků.

// (1) single element pair<iterator, bool> insert(     const value_type& Val );   // (2) single element, perfect forwarded template<class ValTy> pair<iterator, bool> insert(     ValTy&& Val );  // (3) single element with hint iterator insert(     const_iterator Where,     const value_type& Val );   // (4) single element, perfect forwarded, with hint template<class ValTy> iterator insert(     const_iterator Where,     ValTy&& Val );  // (5) range  template<class InputIterator>  void insert(     InputIterator First,     InputIterator Last );   // (6) initializer list void insert(     initializer_list<value_type> IList );

Parametry

Parametr	Popis
Val	Hodnota elementu, který má být vložen do mapy, pokud již obsahuje element, jehož klíč je ekvivalentně řazení.
Where	Místo zahájení vyhledání správného bodu vložení.(Pokud tohoto bodu bezprostředně předchází Where, vložení může dojít v amortizovaný konstantní čas místo logaritmické času.)
ValTy	Parametr šablony, který určuje typ argumentu, mapy můžete vytvořit element value_typea předávat dokonalé Val jako argument.
First	Pozice prvního prvku, který chcete zkopírovat.
Last	Pozice bezprostředně za posledním prvkem, který chcete zkopírovat.
InputIterator	Argument funkce šablony, který splňuje požadavky vstupního iterátoru, který odkazuje na prvky typu, který lze použít k vytvoření objektů value_type.
IList	Seznam initializer_list, ze kterého chcete kopírovat prvky.

Vrácená hodnota

Jeden element členské funkce (1) a (2), vrátí dvojici jehož bool komponenta je hodnota true, pokud bylo provedeno vložení a hodnota false, pokud mapě již obsahuje element, jehož klíč má odpovídající hodnoty v pořadí.Komponenta iterátoru dvojice návratové hodnoty odkazuje na nově vložený prvek, pokud má komponenta bool hodnotu true, nebo na existující prvek, pokud má komponenta bool hodnotu false.

Jeden element s nápovědu členské funkce, (3) a (4) vrátí iterace odkazující na umístění, kde nového elementu byla vložena do mapy, nebo pokud již existuje element se ekvivalentní klíčem, do existujícího elementu.

Poznámky

Touto funkcí nejsou zneplatněny žádné iterátory, ukazatele ani odkazy.

Při vložení pouze jeden prvek Pokud je vyvolána výjimka, stav kontejneru se nemění.Pokud je při vkládání více prvků vyvolána výjimka, kontejner zůstane v neurčeném, ale platném stavu.

To access the iterator component of a pairpr that's returned by the single-element member functions, use pr.first; to dereference the iterator within the returned pair, use *pr.first, giving you an element.Chcete-li přistupovat ke komponentě bool, použijte pr.second.Příklad naleznete v ukázce kódu dále v tomto článku.

Objekt value_type kontejneru je definice typu, který náleží do kontejneru a pro objekt map<K, V>::value_type je pair<const K, V>.Hodnota prvku je seřazená dvojice, ve které je první komponenta rovna hodnotě klíče a druhá komponenta je rovna datové hodnotě prvku.

Členskou funkci rozsahu: [5] vloží posloupnost hodnoty elementů do mapování, která odpovídá každý prvek řešit iterace v rozsahu [First, Last); Proto Last získat není vložena.Členská funkce kontejneru end() se vztahuje k pozici hned za posledním prvkem v kontejneru, například příkaz m.insert(v.begin(), v.end()); se pokusí vložit všechny prvky v do m.Vkládají se pouze prvky, které v rozsahu obsahují jedinečné hodnoty. Duplicitní hodnoty jsou ignorovány.Chcete-li sledovat, které prvky jsou odmítnuty, použijte jednoprvkovou verzi funkce insert.

Člen inicializátoru seznamu funkce (6) používá initializer_list ke zkopírování elementů do mapy.

Další informace o vložení prvku vytvořeného na místě – to znamená, že nejsou provedeny žádné operace kopírování nebo přesunutí – naleznete v tématech map::emplace a map::emplace_hint.

Příklad

// map_insert.cpp
// compile with: /EHsc
#include <map>
#include <iostream>
#include <string>
#include <vector>
#include <utility>  // make_pair()

using namespace std;

template <typename M> void print(const M& m) {
    cout << m.size() << " elements: ";

    for (const auto& p : m) {
        cout << "(" << p.first << ", " << p.second << ") ";
    }

    cout << endl;
}

int main()
{

    // insert single values 
    map<int, int> m1;
    // call insert(const value_type&) version
    m1.insert({ 1, 10 });
    // call insert(ValTy&&) version 
    m1.insert(make_pair(2, 20));

    cout << "The original key and mapped values of m1 are:" << endl;
    print(m1);

    // intentionally attempt a duplicate, single element
    auto ret = m1.insert(make_pair(1, 111));
    if (!ret.second){
        auto pr = *ret.first;
        cout << "Insert failed, element with key value 1 already exists."
            << endl << "  The existing element is (" << pr.first << ", " << pr.second << ")"
            << endl;
    }
    else{
        cout << "The modified key and mapped values of m1 are:" << endl;
        print(m1);
    }
    cout << endl;

    // single element, with hint
    m1.insert(m1.end(), make_pair(3, 30));
    cout << "The modified key and mapped values of m1 are:" << endl;
    print(m1);
    cout << endl;


    // The templatized version inserting a jumbled range
    map<int, int> m2;
    vector<pair<int, int>> v;
    v.push_back(make_pair(43, 294));
    v.push_back(make_pair(41, 262));
    v.push_back(make_pair(45, 330));
    v.push_back(make_pair(42, 277));
    v.push_back(make_pair(44, 311));

    cout << "Inserting the following vector data into m2:" << endl;
    print(v);

    m2.insert(v.begin(), v.end());

    cout << "The modified key and mapped values of m2 are:" << endl;
    print(m2);
    cout << endl;

    // The templatized versions move-constructing elements
    map<int, string>  m3;
    pair<int, string> ip1(475, "blue"), ip2(510, "green");

    // single element
    m3.insert(move(ip1));
    cout << "After the first move insertion, m3 contains:" << endl;
    print(m3);

    // single element with hint
    m3.insert(m3.end(), move(ip2));
    cout << "After the second move insertion, m3 contains:" << endl;
    print(m3);
    cout << endl;

    map<int, int> m4;
    // Insert the elements from an initializer_list
    m4.insert({ { 4, 44 }, { 2, 22 }, { 3, 33 }, { 1, 11 }, { 5, 55 } });
    cout << "After initializer_list insertion, m4 contains:" << endl;
    print(m4);
    cout << endl;
}

Výstup

The original key and mapped values of m1 are:
2 elements: (1, 10) (2, 20)
Insert failed, element with key value 1 already exists.
  The existing element is (1, 10)

The modified key and mapped values of m1 are:
3 elements: (1, 10) (2, 20) (3, 30)

Inserting the following vector data into m2:
5 elements: (43, 294) (41, 262) (45, 330) (42, 277) (44, 311)
The modified key and mapped values of m2 are:
5 elements: (41, 262) (42, 277) (43, 294) (44, 311) (45, 330)

After the first move insertion, m3 contains:
1 elements: (475, blue)
After the second move insertion, m3 contains:
2 elements: (475, blue) (510, green)

After initializer_list insertion, m4 contains:
5 elements: (1, 11) (2, 22) (3, 33) (4, 44) (5, 55)