# std::map<Key,T,Compare,Allocator>::map

< cpp‎ | container‎ | map

map(); explicit map( const Compare& comp, const Allocator& alloc = Allocator() ); | (1) |
explicit map( const Allocator& alloc ); | (1) | (C++11 起)
| (2) |
template< class InputIt > map( InputIt first, InputIt last, const Compare& comp = Compare(), const Allocator& alloc = Allocator() ); |  |
template< class InputIt > map( InputIt first, InputIt last, const Allocator& alloc ); |  | (C++14 起)
map( const map& other ); | (3) |
map( const map& other, const Allocator& alloc ); | (3) | (C++11 起)
map( map&& other ); | (4) | (C++11 起)
map( map&& other, const Allocator& alloc ); | (4) | (C++11 起)
| (5) |
map( std::initializer_list<value_type> init, const Compare& comp = Compare(), const Allocator& alloc = Allocator() ); |  | (C++11 起)
map( std::initializer_list<value_type> init, const Allocator& ); |  | (C++14 起)

从各种数据源构造新容器，可选地使用用户提供的分配器 `alloc` 或比较函数对象 `comp` 。

1) 构造空容器。
2) 构造容器，使之拥有范围 `[first, last)` 的内容。若范围中的多个元素拥有比较等价的关键，则插入哪个元素是未指定的（待决的 LWG2844 ）。
3) 复制构造函数。构造容器，使之拥有 `other` 的内容副本。

若不提供 `alloc` ，则通过调用 std::allocator_traits<allocator_type>::select_on_container_copy_construction( other.get_allocator()) 获得分配器。 | (C++11 起)
在用于类模板实参推导时，仅从首个实参推导模板形参 `Allocator` 。 | (C++23 起)

4) 移动构造函数。用移动语义构造容器，使之拥有 `other` 的内容。若不提供 `alloc` ，则从属于 `other` 的分配器移动构造分配器。

在用于类模板实参推导时，仅从首个实参推导模板形参 `Allocator` 。 | (C++23 起)

5) 构造容器，使之拥有 initializer_list `init` 的内容。若范围中的多个元素拥有比较等价的关键，则插入哪个元素是未指定的（待决的 LWG2844 ）。

### 参数

alloc | - | 用于此容器所有内存分配的分配器
comp | - | 用于所有关键比较的比较函数对象
first, last | - | 复制元素来源的范围
other | - | 要用作源以初始化容器元素的另一容器
init | - | 用以初始化容器元素的 initializer_list
类型要求
- `InputIt` 必须满足老式输入迭代器 (LegacyInputIterator) 的要求。
- `Compare` 必须满足比较 (Compare) 的要求。
- `Allocator` 必须满足分配器 (Allocator) 的要求。

### 复杂度

1) 常数。
2) N log(N) ，其中通常有 N = std::distance(first, last) ，若范围已按照 `value_comp()` 排序则与 `N` 成线性。
3) 与 `other` 的大小成线性。
4) 常数。若给定 `alloc` 且 alloc != other.get_allocator() 则为线性。
5) N log(N) ，其中通常有 N = init.size() ，若 `init` 已按照 `value_comp()` 排序则与 `N` 成线性 。

### 异常

对 `Allocator::allocate` 的调用可能抛出。

### 注解

在容器移动构造（重载 (4) ）后，指向 `other` 的引用及迭代器（除了尾迭代器）保持合法，但指代现于 *this 中的元素。当前标准由 [container.requirements.general]/12 中的总括陈述作出此保证，而 LWG 2321 正在考虑更严格的保证。

尽管在 C++23 前未正式要求，一些实现已经在较早的模式中将 `Allocator` 放入非推导语境。

### 示例

    #include <iostream>
    #include <string>
    #include <iomanip>
    #include <map>

    template<typename Map>
    void print_map(Map& m)
    {
       std::cout << '{';
       for(auto& p: m)
            std::cout << p.first << ':' << p.second << ' ';
       std::cout << "}\n";
    }

    struct Point { double x, y; };
    struct PointCmp {
        bool operator()(const Point& lhs, const Point& rhs) const {
            return lhs.x < rhs.x; // NB 。有意忽略 y
        }
    };

    int main()
    {
      // (1) 默认构造函数
      std::map<std::string, int> map1;
      map1["something"] = 69;
      map1["anything"] = 199;
      map1["that thing"] = 50;
      std::cout << "map1 = "; print_map(map1);

      // (2) 范围构造函数
      std::map<std::string, int> iter(map1.find("anything"), map1.end());
      std::cout << "\niter = "; print_map(iter);
      std::cout << "map1 = "; print_map(map1);

      // (3) 复制构造函数
      std::map<std::string, int> copied(map1);
      std::cout << "\ncopied = "; print_map(copied);
      std::cout << "map1 = "; print_map(map1);

      // (4) 移动构造函数
      std::map<std::string, int> moved(std::move(map1));
      std::cout << "\nmoved = "; print_map(moved);
      std::cout << "map1 = "; print_map(map1);

      // (5) initializer_list 构造函数
      const std::map<std::string, int> init {
        {"this", 100},
        {"can", 100},
        {"be", 100},
        {"const", 100},
      };
      std::cout << "\ninit = "; print_map(init);

      // 定制关键类选项 1 ：
      // 使用比较 struct
      std::map<Point, double, PointCmp> mag = {
          { {5, -12}, 13 },
          { {3, 4},   5 },
          { {-8, -15}, 17 }
      };

      for(auto p : mag)
          std::cout << "The magnitude of (" << p.first.x
                    << ", " << p.first.y << ") is "
                    << p.second << '\n';

      // 定制关键类选项 2 ：
      // 使用比较 lambda
      // 此 lambda 按照其模比较点，注意其中模取自局部变量 mag
      auto cmpLambda = [&mag](const Point &lhs, const Point &rhs) { return mag[lhs] < mag[rhs]; };
      // 你亦可使用不依赖局部变量的 lambda ，像这样：
      // auto cmpLambda = [](const Point &lhs, const Point &rhs) { return lhs.y < rhs.y; };
      std::map<Point, double, decltype(cmpLambda)> magy(cmpLambda);

      // 各种插入元素的方式：
      magy.insert(std::pair<Point, double>({5, -12}, 13));
      magy.insert({ {3, 4}, 5});
      magy.insert({Point{-8.0, -15.0}, 17});

      std::cout << '\n';
      for(auto p : magy)
          std::cout << "The magnitude of (" << p.first.x
                    << ", " << p.first.y << ") is "
                    << p.second << '\n';
    }

输出：

    map1 = {anything:199 something:69 that thing:50 }

    iter = {anything:199 something:69 that thing:50 }
    map1 = {anything:199 something:69 that thing:50 }

    copied = {anything:199 something:69 that thing:50 }
    map1 = {anything:199 something:69 that thing:50 }

    moved = {anything:199 something:69 that thing:50 }
    map1 = {}

    init = {be:100 can:100 const:100 this:100 }
    The magnitude of (-8, -15) is 17
    The magnitude of (3, 4) is 5
    The magnitude of (5, -12) is 13

    The magnitude of (3, 4) is 5
    The magnitude of (5, -12) is 13
    The magnitude of (-8, -15) is 17

### 缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

DR | 应用于 | 出版时的行为 | 正确行为
--- | --- | --- | ---
LWG 2193 | C++11 | 默认构造函数为 explicit | 使之为非 explicit

### 参阅

operator= | 赋值给容器 (公开成员函数)