map<Key, Data, Compare, Alloc>


类别：容器	组件类型：类型

描述

映射是一个有序关联容器，它将类型为Key的对象与类型为Data. 映射的对象关联起来。它是一个配对关联容器，这意味着它的值类型是pair<const Key, Data>。它也是一个唯一关联容器，这意味着没有两个元素具有相同的键。

映射具有一个重要特性，即向map中插入新元素不会使指向现有元素的迭代器失效。从map中删除元素也不会使任何迭代器失效，当然，除了实际指向被删除元素的迭代器。

示例

struct ltstr
{
  bool operator()(const char* s1, const char* s2) const
  {
    return strcmp(s1, s2) < 0;
  }
};

int main()
{
  map<const char*, int, ltstr> months;
  
  months["january"] = 31;
  months["february"] = 28;
  months["march"] = 31;
  months["april"] = 30;
  months["may"] = 31;
  months["june"] = 30;
  months["july"] = 31;
  months["august"] = 31;
  months["september"] = 30;
  months["october"] = 31;
  months["november"] = 30;
  months["december"] = 31;
  
  cout << "june -> " << months["june"] << endl;
  map<const char*, int, ltstr>::iterator cur  = months.find("june");
  map<const char*, int, ltstr>::iterator prev = cur;
  map<const char*, int, ltstr>::iterator next = cur;    
  ++next;
  --prev;
  cout << "Previous (in alphabetical order) is " << (*prev).first << endl;
  cout << "Next (in alphabetical order) is " << (*next).first << endl;
}

定义

在标准头文件map中定义，并在非标准向后兼容头文件map.h中定义。

模板参数

参数	描述	默认值
`Key`	映射的键类型。这也定义为`map::key_type`.
`Data`	映射的数据类型。这也定义为`map::data_type`.
`Compare`	键比较函数，一个严格弱排序，其参数类型为`key_type`；它返回`true`如果其第一个参数小于第二个参数，否则返回`false`。这也定义为`map::key_compare`.	`less<Key>`
`Alloc`	map`map`的分配器，用于所有内部内存管理。	`alloc`

模型

唯一有序关联容器，配对关联容器

类型要求

Data是可赋值的。
Compare是一个严格弱排序，其参数类型为Key.
Alloc是一个分配器。

公共基类

无。

成员

成员	定义位置	描述
`key_type`	关联容器	map`map`的键类型，`Key`.
`data_type`	配对关联容器	与键关联的对象的类型。
`value_type`	配对关联容器	对象的类型，`pair<const key_type, data_type>`，存储在映射中。
`key_compare`	有序关联容器	函数对象，用于比较两个键的顺序。
`value_compare`	有序关联容器	函数对象，用于比较两个值的顺序。
`pointer`	容器	指向`T`.
`reference`	容器	指向`T`
`const_reference`	容器	指向常量的引用`T`
`size_type`	容器	无符号整型。
`difference_type`	容器	有符号整型。
`iterator`	容器	用于遍历`map`. [1]
`const_iterator`	容器	用于遍历`map`.
`reverse_iterator`	可逆容器	用于反向遍历`map`. [1]
`const_reverse_iterator`	可逆容器	用于反向遍历`map`.
`iterator begin()`	容器	返回一个`iterator`指向映射开头的迭代器。`map`.
`iterator end()`	容器	返回一个`iterator`指向映射结尾的迭代器。`map`.
`const_iterator begin() const`	容器	返回一个`const_iterator`指向映射开头的迭代器。`map`.
`const_iterator end() const`	容器	返回一个`const_iterator`指向映射结尾的迭代器。`map`.
`reverse_iterator rbegin()`	可逆容器	返回一个`reverse_iterator`指向反转映射开头的迭代器。
`reverse_iterator rend()`	可逆容器	返回一个`reverse_iterator`指向反转映射结尾的迭代器。
`const_reverse_iterator rbegin() const`	可逆容器	返回一个`const_reverse_iterator`指向反转映射开头的迭代器。
`const_reverse_iterator rend() const`	可逆容器	返回一个`const_reverse_iterator`指向反转映射结尾的迭代器。
`size_type size() const`	容器	返回映射的大小。`map`.
`size_type max_size() const`	容器	返回映射的最大可能大小。`map`.
`bool empty() const`	容器	`true`如果映射的大小为`map`0`0`.
`key_compare key_comp() const`	有序关联容器	返回`key_compare`映射使用的`map`.
`value_compare value_comp() const`	有序关联容器	返回`value_compare`映射使用的`map`.
`map()`	容器	创建一个空的`map`.
`map(const key_compare& comp)`	有序关联容器	创建一个空的`map`，使用`comp`作为`key_compare`对象。
template <class InputIterator> map(InputIterator f, InputIterator l) [2]	唯一有序关联容器	创建一个包含范围副本的映射。
template <class InputIterator> map(InputIterator f, InputIterator l, const key_compare& comp) [2]	唯一有序关联容器	创建一个包含范围副本的映射，使用`comp`作为`key_compare`对象。
`map(const map&)`	容器	复制构造函数。
`map& operator=(const map&)`	容器	赋值运算符
`void swap(map&)`	容器	交换两个映射的内容。
pair<iterator, bool> insert(const value_type& x)	唯一关联容器	将`x`插入到`map`.
iterator insert(iterator pos, const value_type& x)	唯一有序关联容器	将`x`插入到`map`，使用`pos`作为插入位置的提示。
template <class InputIterator> void insert(InputIterator, InputIterator) [2]	唯一有序关联容器	将一个范围插入到`map`.
`void erase(iterator pos)`	关联容器	删除`pos`.
`size_type erase(const key_type& k)`	关联容器	删除键为`k`.
`void erase(iterator first, iterator last)`	关联容器	删除范围内的所有元素。
`void clear()`	关联容器	删除所有元素。
`iterator find(const key_type& k)`	关联容器	查找键为`k`.
`const_iterator find(const key_type& k) const`	关联容器	查找键为`k`.
`size_type count(const key_type& k)`	唯一关联容器	统计键为`k`.
`iterator lower_bound(const key_type& k)`	有序关联容器	查找键不小于`k`.
`const_iterator lower_bound(const key_type& k) const`	有序关联容器	查找键不小于`k`.
`iterator upper_bound(const key_type& k)`	有序关联容器	查找键大于`k`.
`const_iterator upper_bound(const key_type& k) const`	有序关联容器	查找键大于`k`.
pair<iterator, iterator> equal_range(const key_type& k)	有序关联容器	查找包含所有键为`k`.
pair<const_iterator, const_iterator> equal_range(const key_type& k) const	有序关联容器	查找包含所有键为`k`.
data_type& operator[](const key_type& k) [3]	`map`	参见下文。
bool operator==(const map&, const map&)	前向容器	测试两个映射是否相等。这是一个全局函数，而不是成员函数。
bool operator<(const map&, const map&)	前向容器	词典比较。这是一个全局函数，而不是成员函数。

新成员

这些成员未在唯一有序关联容器和配对关联容器要求中定义，而是map:

成员函数	描述
data_type& operator[](const key_type& k) [3]	返回对与特定键关联的对象的引用。如果`map`尚不包含此类对象，`operator[]`则插入默认对象`data_type()`. [3]

注释

[1] Map::iterator不是可变迭代器，因为map::value_type不是可赋值的。也就是说，如果i的类型为map::iterator并且p的类型为map::value_type，则*i = p不是有效的表达式。但是，map::iterator也不是常量迭代器，因为它可以用来修改它指向的对象。使用与上面相同的符号，(*i).second = p是一个有效的表达式。同样的观点也适用于map::reverse_iterator.

[2] 此成员函数依赖于成员模板函数，目前（1998年初）并非所有编译器都支持。如果您的编译器支持成员模板，则可以使用任何类型的输入迭代器调用此函数。但是，如果您的编译器尚不支持成员模板，则参数必须是类型为const value_type*或类型为map::const_iterator.

[3] 由于operator[]可能会将新元素插入到map中，因此它不可能是const成员函数。请注意，operator[]的定义非常简单m[k]等价于(*((m.insert(value_type(k, data_type()))).first)).second。严格来说，此成员函数是不必要的：它只为了方便而存在。

另请参阅

关联容器，有序关联容器，配对关联容器，唯一有序关联容器，set multiset, multimap, hash_set, hash_map, hash_multiset, hash_multimap,