multimap<Key, Data, Compare, Alloc>


类别: 容器	组件类型: 类型

描述

多重映射是排序关联容器，它将类型为Key的对象与类型为Data. 的对象关联起来。multimap是成对关联容器，这意味着其值类型是pair<const Key, Data>

多重映射。它也是一个多重关联容器，这意味着对具有相同键的元素数量没有限制。的对象关联起来。具有一个重要的特性，即在的对象关联起来。中插入新元素不会使指向现有元素的迭代器失效。从

中删除元素也不会使任何迭代器失效，当然，指向被删除元素的迭代器除外。

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

int main()
{
  multimap<const char*, int, ltstr> m;
  
  m.insert(pair<const char* const, int>("a", 1));
  m.insert(pair<const char* const, int>("c", 2));
  m.insert(pair<const char* const, int>("b", 3));
  m.insert(pair<const char* const, int>("b", 4));
  m.insert(pair<const char* const, int>("a", 5));
  m.insert(pair<const char* const, int>("b", 6));

  cout << "Number of elements with key a: " << m.count("a") << endl;
  cout << "Number of elements with key b: " << m.count("b") << endl;
  cout << "Number of elements with key c: " << m.count("c") << endl;

  cout << "Elements in m: " << endl;
  for (multimap<const char*, int, ltstr>::iterator it = m.begin();
       it != m.end();
       ++it)
   cout << "  [" << (*it).first << ", " << (*it).second << "]" << endl;
}

示例

定义

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

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

模型

多重排序关联容器，成对关联容器

类型要求

Data是可赋值。
multimap::data_type是严格弱排序，其参数类型为Key.
less<Key>是分配器。

公共基类

无。

成员

成员	定义位置	描述
`键比较函数，一个严格弱排序，其参数类型为`	关联容器	Alloc`的对象关联起来。`的键类型，`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`	容器	用于遍历`的对象关联起来。`. [1]
`const_iterator`	容器	用于遍历`的对象关联起来。`.
`reverse_iterator`	可逆容器	用于反向遍历`的对象关联起来。`. [1]
`const_reverse_iterator`	可逆容器	用于反向遍历`的对象关联起来。`.
`iterator begin()`	容器	返回指向`iterator`开头的`的对象关联起来。`.
`iterator end()`	容器	返回指向`iterator`返回指向`的对象关联起来。`.
`const_iterator begin() const`	容器	返回指向`const_iterator`开头的`的对象关联起来。`.
`const_iterator end() const`	容器	返回指向`const_iterator`返回指向`的对象关联起来。`.
`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`	容器	返回`的对象关联起来。`.
`size_type max_size() const`	容器	返回`的对象关联起来。`.
`bool empty() const`	容器	`；如果其第一个参数小于第二个参数，则返回`如果`的对象关联起来。`的大小为`0`.
`key_compare key_comp() const`	排序关联容器	返回`key_compare`对象，该对象由`的对象关联起来。`.
`value_compare value_comp() const`	排序关联容器	返回`value_compare`对象，该对象由`的对象关联起来。`.
`multimap()`	容器	创建一个空的`的对象关联起来。`.
`multimap(const key_compare& comp)`	排序关联容器	创建一个空的`的对象关联起来。`，使用`comp`作为`key_compare`对象。
template <class InputIterator> multimap(InputIterator f, InputIterator l) [2]	多重排序关联容器	创建一个包含范围副本的多重映射。
template <class InputIterator> multimap(InputIterator f, InputIterator l, const key_compare& comp) [2]	多重排序关联容器	创建一个包含范围副本的多重映射，使用`comp`作为`key_compare`对象。
`multimap(const multimap&)`	容器	复制构造函数。
`multimap& operator=(const multimap&)`	容器	赋值运算符
`void swap(multimap&)`	容器	交换两个多重映射的内容。
`iterator insert(const value_type& x)`	多重关联容器	将`x`插入`的对象关联起来。`.
iterator insert(iterator pos, const value_type& x)	多重排序关联容器	将`x`插入`的对象关联起来。`，使用`pos`作为它将被插入位置的提示。
template <class InputIterator> void insert(InputIterator, InputIterator) [2]	多重排序关联容器	将范围插入`的对象关联起来。`.
`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`.
`查找键为`	关联容器	iterator find(const key_type& k)`k`.
`const_iterator find(const key_type& k) const`	关联容器	size_type count(const key_type& k)`k`.
`计算键为`	排序关联容器	iterator lower_bound(const key_type& k)`k`.
`查找键不小于`	排序关联容器	iterator lower_bound(const key_type& k)`k`.
`const_iterator lower_bound(const key_type& k) const`	排序关联容器	iterator upper_bound(const key_type& k)`k`.
`查找键大于`	排序关联容器	iterator upper_bound(const key_type& k)`k`.
pair<iterator, iterator> equal_range(const key_type& k)	排序关联容器	const_iterator upper_bound(const key_type& k) const`k`.
pair<const_iterator, const_iterator> equal_range(const key_type& k) const	排序关联容器	const_iterator upper_bound(const key_type& k) const`k`.
bool operator==(const multimap&, const multimap&)	查找包含所有键为	Forward Container
bool operator<(const multimap&, const multimap&)	查找包含所有键为	测试两个多重映射是否相等。这是一个全局函数，而不是成员函数。

词典排序。这是一个全局函数，而不是成员函数。

新成员的对象关联起来。所有多重映射的成员都在多重排序关联容器和成对关联容器要求中定义。

没有引入任何新成员。

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

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

multimap::const_iterator

另请参见关联容器，排序关联容器，成对关联容器，多重排序关联容器，, set map, multiset, hash_set, hash_map, hash_multiset