map::map

构造一个映射或是一些其它映射的全部或者部分复制。

map( );
explicit map(
    const Traits& Comp
);
map(
    const Traits& Comp,
    const Allocator& Al
);
map(
    const map& Right
); 
map(
    map&& Right
);
map(
    initializer_list<value_type> IList
);
map(
    initializer_list<value_type> IList,
    const Traits& Comp
);
map(
    initializer_list<value_type> IList,
    const Traits& Comp, 
    const Allocator& Allocator
);
template<class InputIterator>
    map(
        InputIterator First,
        InputIterator Last
    );
template<class InputIterator>
    map(
        InputIterator First,
        InputIterator Last,
        const Traits& Comp
    );
template<class InputIterator>
    map(
        InputIterator First,
        InputIterator Last,
        const Traits& Comp,
        const Allocator& Al
    );

参数

参数	说明
Al	存储分配器类在映射 对象中使用，默认遵守 Allocator。
Comp	默认遵守的类型const Traits的比较函数用来排序hash_compare中的元素。
Right	构造设置的映射是副本。
First	要复制的元素范围中的第一个元素的位置。
Last	要复制的元素范围之外的第一个元素的位置。
IList	组件将复制的 initializer_list。

备注

所有构造函数存储了一个为映射管理内存存储的分配器对象的类型并且此对象能够通过调用get_allocator返回。 分配器参数通常在所使用的类声明和用于替换分配器的预处理器宏被忽略。

所有构造函数初始化它们的映射。

所有的构造函数存储了一个用来在映射的关键值中建立排序的函数对象类型，并且接下来可以通过调用5fwftdtk(v=vs.120).md 返回。

初始的三个构造函数指定了空的初始映射, 第二个构造函数则指定了用来建立元素次序的比较函数(Comp)的类型，第三个构造函数则明确指定了使用的分配器类型 (Al) 。 关键字explicit抑制了一些种类的自动类型转换。

第四个构造函数指定了映射Right 的副本。

第五个构造函数通过移动Right指定了映射的副本。

第六，第七和第七八个构造函数使用复制成员的initializer_list。

接下来的最后三个构造函数复制了在类Traits和分配器的比较函数类型中明显增长的映射范围 [First, Last) 。

示例

// map_map.cpp
// compile with: /EHsc
#include <map>
#include <iostream>

int main()
{
    using namespace std;
    typedef pair <int, int> Int_Pair;
    map <int, int>::iterator m1_Iter, m3_Iter, m4_Iter, m5_Iter, m6_Iter, m7_Iter;
    map <int, int, less<int> >::iterator m2_Iter;

    // Create an empty map m0 of key type integer
    map <int, int> m0;

    // Create an empty map m1 with the key comparison
    // function of less than, then insert 4 elements
    map <int, int, less<int> > m1;
    m1.insert(Int_Pair(1, 10));
    m1.insert(Int_Pair(2, 20));
    m1.insert(Int_Pair(3, 30));
    m1.insert(Int_Pair(4, 40));

    // Create an empty map m2 with the key comparison
    // function of geater than, then insert 2 elements
    map <int, int, less<int> > m2;
    m2.insert(Int_Pair(1, 10));
    m2.insert(Int_Pair(2, 20));

    // Create a map m3 with the 
    // allocator of map m1
    map <int, int>::allocator_type m1_Alloc;
    m1_Alloc = m1.get_allocator();
    map <int, int> m3(less<int>(), m1_Alloc);
    m3.insert(Int_Pair(3, 30));

    // Create a copy, map m4, of map m1
    map <int, int> m4(m1);

    // Create a map m5 by copying the range m1[_First, _Last)
    map <int, int>::const_iterator m1_bcIter, m1_ecIter;
    m1_bcIter = m1.begin();
    m1_ecIter = m1.begin();
    m1_ecIter++;
    m1_ecIter++;
    map <int, int> m5(m1_bcIter, m1_ecIter);

    // Create a map m6 by copying the range m4[_First, _Last)
    // and with the allocator of map m2
    map <int, int>::allocator_type m2_Alloc;
    m2_Alloc = m2.get_allocator();
    map <int, int> m6(m4.begin(), ++m4.begin(), less<int>(), m2_Alloc);

    cout << "m1 =";
    for (auto i : m1)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m2 =";
    for(auto i : m2)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m3 =";
    for (auto i : m3)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m4 =";
    for (auto i : m4)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m5 =";
    for (auto i : m5)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    cout << "m6 =";
    for (auto i : m6)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m7 by moving m5
    cout << "m7 =";
    map<int, int> m7(move(m5));
    for (auto i : m7)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m8 by copying in an initializer_list
    map<int, int> m8{ { { 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 } } };
    cout << "m8: = ";
    for (auto i : m8)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m9 with an initializer_list and a comparator
    map<int, int> m9({ { 5, 5 }, { 6, 6 }, { 7, 7 }, { 8, 8 } }, less<int>());
    cout << "m9: = ";
    for (auto i : m9)
        cout << i.first << " " << i.second << ", ";
    cout << endl;

    // Create a map m10 with an initializer_list, a comparator, and an allocator
    map<int, int> m10({ { 9, 9 }, { 10, 10 }, { 11, 11 }, { 12, 12 } }, less<int>(), m9.get_allocator());
    cout << "m10: = ";
    for (auto i : m10)
        cout << i.first << " " << i.second << ", ";
    cout << endl;
}

Output

m1 = 10 20 30 40
m2 = 10 20
m3 = 30
m4 = 10 20 30 40
m5 = 10 20
m6 = 10
m7 = 10 20
m8: = 1 1, 2 2, 3 3, 4 4,
m9: = 5 5, 6 6, 7 7, 8 8,
m10: = 9 9, 10 10, 11 11, 12 12,

要求

标头: <map>

命名空间: std

请参见

参考

map 类

标准模板库