class unordered_multimap;

//

//

//template<class Key,

//class Ty,

//class Hash = std::hash<Key>,

//class Pred = std::equal_to<Key>,

//class Alloc = std::allocator<Key> >

//class unordered_multimap;

//对象通过调用两个存储对象，即一个 unordered_multimap::key_equal 类型的比较函数对象和一个 unordered_multimap::hasher 类型的哈希函数对象，对它控制的序列进行排序。 

//可以通过调用成员函数 unordered_multimap::key_eq() 访问第一个存储对象；通过调用成员函数 unordered_multimap::hash_function() 访问第二个存储对象。 

//具体而言，对于所有 Key 类型的值 X 和 Y，key_eq()(X, Y) 调用将仅在两个参数值拥有等效顺序时返回 true；hash_function()(keyval) 调用将生成 size_t 类型的值的分布。 与模板类 unordered_map 类 不同，模板类 unordered_multimap 的对象不确保 key_eq()(X, Y) 对于受控序列的任意两个元素始终为 false。（键不需要唯一。）

//

//此对象还存储最大加载因子，用于指定每个存储桶的元素的最大所需平均数量。 如果插入元素导致 unordered_multimap::load_factor() 超出最大加载因子，容器将增加存储桶的数量并根据需要重新生成哈希表。

//

//受控序列中元素的实际顺序取决于哈希函数、比较函数、插入顺序、最大加载因子和存储桶的当前数量。 通常无法预测受控序列中的元素顺序。 但是，可以始终确保具有等效顺序的任何元素子集在受控序列中相邻。

//

//对象通过 unordered_multimap::allocator_type 类型的存储分配器对象为其控制的序列分配并释放存储。 此分配器对象必须与 allocator 模板类的对象的外部接口相同。 请注意，已分配容器对象时，不复制存储的分配器对象。

//

//此模板类描述用于控制std::pair<const Key, Ty>类型的变长元素序列的对象。序列由哈希函数弱排序，哈希函数将此序列分区到称为存储桶的有序序列集中。在每个存储桶中，比较函数将确定任一元素对是否具有等效顺序。每个元素存储两个对象，包括一个排序键和一个值。序列以允许查找、插入和移除任意元素的方式表示，并包含与序列中的元素数量无关的多个操作（常量时间），至少在所有存储桶长度大致相等时如此。在最坏情况下，当所有元素位于一个存储桶中时，操作数量与序列中的元素数量成比例（线性时间）。此外，插入元素不会使迭代器失效，移除元素仅会使指向已移除元素的迭代器失效。

//

//

//

//1.unordered_multimap::allocator_type    用于管理存储的分配器的类型。 

//

//typedef Alloc allocator_type;

//备注//--------------------------------------------------------------------------------

// 类型是一个Alloc模板参数分配的同义词。

//示例//--------------------------------------------------------------------------------

//

//

#include <unordered_map> 

#include <iostream> 

typedef std::unordered_multimap<char, int> Mymap;

typedef std::allocator<std::pair<const char, int> > Myalloc;

int main()

{

   Mymap c1;

   Mymap::allocator_type al = c1.get_allocator();

   std::cout << "al == std::allocator() is "

 << std::boolalpha << (al == Myalloc()) << std::endl;

   return (0);

}

//al == std::allocator() 为 true

//2,unordered_multimap::const_iterator受控序列的常量迭代器的类型。

//

//typedef T1 const_iterator;

//此类型描述为可用作受控序列的常量向前迭代器的对象。 在此处描述为实现定义的类型 T1 的同义词。

//#include <unordered_map> 

//#include <iostream> 

//

//   typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   return (0);

//}

//

////unordered_multimap::const_local_iterator受控序列的常量存储桶迭代器的类型。

////typedef T5 const_local_iterator;

//

////备注//--------------------------------------------------------------------------------

////

////描述类型可以作为常数的前向迭代数。对于存储桶的对象。 

//// 该类型描述了一个对象，该对象可以作为一个常数向前的一个桶。这里描述为实现定义型T5的同义词。

////示例//--------------------------------------------------------------------------------

//

//

//

//#include <unordered_map> 

//#include <iostream> 

//

//   typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // inspect bucket containing 'a' 

//   Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));

//   std::cout << " [" << lit->first << ", " << lit->second << "]";

//

//   return (0);

//}

//// std_tr1__unordered_map__unordered_multimap_const_local_iterator.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // inspect bucket containing 'a' 

//   Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));

//   std::cout << " [" << lit->first << ", " << lit->second << "]";

//

//   return (0);

//}

//

//

//

////unordered_multimap::const_pointer元素的常量指针的类型。

////typedef Alloc::const_pointer const_pointer;该类型将可作为常量指针的对象描述为受控序列中的元素。

//

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::iterator it = c1.begin();

//   it != c1.end(); ++it)

//   {

//  Mymap::const_pointer p = &*it;

//  std::cout << " [" << p->first << ", " << p->second << "]";

//   }

//   std::cout << std::endl;

//

//   return (0);

//}

//

//

////unordered_multimap::const_reference元素的常量引用的类型。

////typedef Alloc::const_reference const_reference;类型描述可以充当对控制序列元素的常量引用的对象。

//// std_tr1__unordered_map__unordered_multimap_const_reference.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::iterator it = c1.begin();

//   it != c1.end(); ++it)

//   {

//  Mymap::const_reference ref = *it;

//  std::cout << " [" << ref.first << ", " << ref.second << "]";

//   }

//   std::cout << std::endl;

//

//   return (0);

//}

//

////unordered_multimap::difference_type两个元素间的带符号距离的类型。

////带符号整数类型描述可以表示任何两个元素间的差异。地址控件序列的对象。 它介绍此处，实现定义类型 T3的同义词。

//// std_tr1__unordered_map__unordered_multimap_difference_type.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // compute positive difference 

//   Mymap::difference_type diff = 0;

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  ++diff;

//   std::cout << "end()-begin() == " << diff << std::endl;

//

//   // compute negative difference 

//   diff = 0;

//   for (Mymap::const_iterator it = c1.end();

//   it != c1.begin(); --it)

//  --diff;

//   std::cout << "begin()-end() == " << diff << std::endl;

//

//   return (0);

//}

//

////unordered_multimap::hasher哈希函数的类型。

////typedef Hash hasher;

//// std_tr1__unordered_map__unordered_multimap_hasher.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   Mymap::hasher hfn = c1.hash_function();

//   std::cout << "hfn('a') == " << hfn('a') << std::endl;

//   std::cout << "hfn('b') == " << hfn('b') << std::endl;

//

//   return (0);

//}

////unordered_multimap::iterator受控序列的迭代器的类型。

////typedef T0 iterator;

////类型描述了一个对象，该对象可以作为控制序列的前向迭代器。这里描述为实现定义的类型的T0的同义词。

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   return (0);

//}

////unordered_multimap::key_equal比较函数的类型。

////类型是Pred模板参数的同义词。

//// std_tr1__unordered_map__unordered_multimap_key_equal.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   Mymap::key_equal cmpfn = c1.key_eq();

//   std::cout << "cmpfn('a', 'a') == "

//  << std::boolalpha << cmpfn('a', 'a') << std::endl;

//   std::cout << "cmpfn('a', 'b') == "

//  << std::boolalpha << cmpfn('a', 'b') << std::endl;

//

//   return (0);

//}

//

////unordered_multimap::key_type排序键的类型。

////typedef Key key_type;类型是Key模板参数的同义词。Key模板参数

//// std_tr1__unordered_map__unordered_multimap_key_type.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // add a value and reinspect 

//   Mymap::key_type key = 'd';

//   Mymap::mapped_type mapped = 4;

//   Mymap::value_type val = Mymap::value_type(key, mapped);

//   c1.insert(val);

//

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   return (0);

//}

//

//

////unordered_multimap::local_iterator受控序列的存储桶迭代器的类型。

////typedef T4 local_iterator;  

////类型描述了一个可以作为一个向前的一个迭代器的对象。这里描述为实现定义型T4的同义词。

//// std_tr1__unordered_map__unordered_multimap_local_iterator.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // inspect bucket containing 'a' 

//   Mymap::local_iterator lit = c1.begin(c1.bucket('a'));

//   std::cout << " [" << lit->first << ", " << lit->second << "]";

//

//   return (0);

//}

////unordered_multimap::mapped_type与每个键关联的映射值的类型。

////typedef Ty mapped_type;类型是Ty模板参数的同义词。

//// std_tr1__unordered_map__unordered_multimap_mapped_type.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // add a value and reinspect 

//   Mymap::key_type key = 'd';

//   Mymap::mapped_type mapped = 4;

//   Mymap::value_type val = Mymap::value_type(key, mapped);

//   c1.insert(val);

//

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   return (0);

//}

//

////unordered_multimap::pointer元素的指针的类型。

////typedef Alloc::pointer pointer;类型来描述可用作指向控制序列的元素的对象。

//// std_tr1__unordered_map__unordered_multimap_pointer.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::iterator it = c1.begin();

//   it != c1.end(); ++it)

//   {

//  Mymap::pointer p = &*it;

//  std::cout << " [" << p->first << ", " << p->second << "]";

//   }

//   std::cout << std::endl;

//

//   return (0);

//}

//

////unordered_multimap::reference元素的引用的类型。

////typedef Alloc::reference reference;类型描述可以充当对控制序列的元素的引用的对象。

//// std_tr1__unordered_map__unordered_multimap_reference.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::iterator it = c1.begin();

//   it != c1.end(); ++it)

//   {

//  Mymap::reference ref = *it;

//  std::cout << " [" << ref.first << ", " << ref.second << "]";

//   }

//   std::cout << std::endl;

//

//   return (0);

//}

////unordered_multimap::size_type两个元素间的无符号距离的类型。

////typedef T2 size_type;  无符号整数类型描述一个可以表示任意控制序列长度的对象。这里描述为实现定义的T2型的同义词。

//// std_tr1__unordered_map__unordered_multimap_size_type.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//   Mymap::size_type sz = c1.size();

//

//   std::cout << "size == " << sz << std::endl;

//

//   return (0);

//}

////unordered_multimap::value_type元素的类型。

////typedef std::pair<const Key, Ty> value_type;描述控制类型序列的元素。

////// std_tr1__unordered_map__unordered_multimap_value_type.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // add a value and reinspect 

//   Mymap::key_type key = 'd';

//   Mymap::mapped_type mapped = 4;

//   Mymap::value_type val = Mymap::value_type(key, mapped);

//   c1.insert(val);

//

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   return (0);

//}

////成员函数说明

////

////unordered_multimap::begin 指定控制序列或存储桶的开头。

////iterator begin();

////const_iterator begin() const;

////local_iterator begin(size_type nbucket);//nbucket 存储数字

////const_local_iterator begin(size_type nbucket) const;

////前两点成员函数返回序列中的第一个元素的前向迭代器(或受一个空序列。结束)。 最后两个成员函数返回指向在存储桶 nbucket 的第一个元素用于向前迭代器(或受空的存储桶。结束)。

////前两个成员函数返回一个前向迭代器，该迭代器指向序列的第一个元素（或在空序列的末端）。最后两个成员函数返回前向迭代器在存储桶nbucket第一元点（或只是超出一个空桶底）。

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // inspect first two items " [c 3] [b 2]" 

//   Mymap::iterator it2 = c1.begin();

//   std::cout << " [" << it2->first << ", " << it2->second << "]";

//   ++it2;

//   std::cout << " [" << it2->first << ", " << it2->second << "]";

//   std::cout << std::endl;

//

//   // inspect bucket containing 'a' 

//   Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));

//   std::cout << " [" << lit->first << ", " << lit->second << "]";

//

//   return (0);

//}

//

//

////

////unordered_multimap::bucket获取键值的存储桶编号。

////size_type bucket(const Key& keyval) const;//keyval 映射的键值。

////成员函数返回当前数字存储桶与键值的 keyval。这个函数返回的桶数目前对应keyval关键值。

//// std_tr1__unordered_map__unordered_multimap_bucket.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // display buckets for keys 

//   Mymap::size_type bs = c1.bucket('a');

//   std::cout << "bucket('a') == " << bs << std::endl;

//   std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)

//  << std::endl;

//

//   return (0);

//}

////unordered_multimap::bucket_count获取存储桶数。

////size_type bucket_count() const;成员函数返回存储桶的当前数目。

//// std_tr1__unordered_map__unordered_multimap_bucket_count.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // inspect current parameters 

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_bucket_count() == "

//  << c1.max_bucket_count() << std::endl;

//   std::cout << "max_load_factor() == "

//  << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   // change max_load_factor and redisplay 

//   c1.max_load_factor(0.10f);

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_bucket_count() == "

//  << c1.max_bucket_count() << std::endl;

//   std::cout << "max_load_factor() == "

//  << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   // rehash and redisplay 

//   c1.rehash(100);

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_bucket_count() == "

//  << c1.max_bucket_count() << std::endl;

//   std::cout << "max_load_factor() == "

//  << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   return (0);

//}

////unordered_multimap::bucket_size获取存储桶的大小。

////size_type bucket_size(size_type nbucket) const;//nbucket存储桶编号。成员函数将返回存储桶编号为 nbucket 的大小。

//// std_tr1__unordered_map__unordered_multimap_bucket_size.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // display buckets for keys 

//   Mymap::size_type bs = c1.bucket('a');

//   std::cout << "bucket('a') == " << bs << std::endl;

//   std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)

//  << std::endl;

//

//   return (0);

//}

//

//

//

////unordered_multimap::cbegin指定受控序列的开头。

////返回确定范围中第一个元素地址的 const 迭代器。

////const_iterator cbegin() const;

////const 前向访问迭代器，指向范围的第一个元素，或刚超出空范围末尾的位置（对于空范围，cbegin() == cend()）。

////由于使用 cbegin 的返回值，因此不能修改范围中的元素。

////

////可以使用此成员函数替代 begin() 成员函数，以保证返回值为 const_iterator。 它一般与 auto 类型推导关键字联合使用，如下例所示。 在该示例中，将 Container 视为支持 begin() 和 cbegin() 的任何类型的可修改（非 const）的容器。

////auto i1 = Container.begin();  // i1 is Container<T>::iterator 

////auto i2 = Container.cbegin(); // i2 is Container<T>::const_iterator

//

////unordered_multimap::cend指定受控序列的末尾。

////返回一个 const 迭代器，此迭代器用于发现刚超出范围中最后一个元素的位置。

////const_iterator cend() const;//指向刚超出范围末尾的位置的 const 向前访问迭代器。

////cend 用于测试迭代器是否超过了其范围的末尾。

////可以使用此成员函数替代 end() 成员函数，以保证返回值为 const_iterator。 它一般与 auto 类型推导关键字联合使用，如下例所示。 在此示例中，将 Container 视为支持 end() 和 cend() 的任何类型的可修改（非 const）容器。

////auto i1 = Container.end();  // i1 is Container<T>::iterator 

////auto i2 = Container.cend(); // i2 is Container<T>::const_iterator

//

//

////unordered_multimap::clear移除所有元素。

////

//

////void clear();

//成员函数可调用 unordered_multimap::erase(unordered_multimap::begin(), unordered_multimap::end())。

//// std_tr1__unordered_map__unordered_multimap_clear.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // clear the container and reinspect 

//   c1.clear();

//   std::cout << "size == " << c1.size() << std::endl;

//   std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

//   std::cout << std::endl;

//

//   c1.insert(Mymap::value_type('d', 4));

//   c1.insert(Mymap::value_type('e', 5));

//

//   // display contents " [e 5] [d 4]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   std::cout << "size == " << c1.size() << std::endl;

//   std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

//

//   return (0);

//}

////unordered_multimap::count查看与指定键的元素的数目。

////size_type count(const Key& keyval) const;//keyval 搜索的键值。

////成员函数返回在划定的范围unordered_multimap元素个数：：equal_range（keyval）。 unordered_multimap::equal_range分隔的范围的(keyval)。

//// std_tr1__unordered_map__unordered_multimap_count.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   std::cout << "count('A') == " << c1.count('A') << std::endl;

//   std::cout << "count('b') == " << c1.count('b') << std::endl;

//   std::cout << "count('C') == " << c1.count('C') << std::endl;

//

//   return (0);

//}

//

//

////unordered_multimap::emplace添加就地构造的元素。

////在适当的位置插入构造的元素(不执行复制或移动操作)，附带位置提示。

//template<class... Args>

//iterator emplace(

//   Args&&... args);

//template<class... Args>

//iterator emplace(

//   Args&&... args);

//

////args传递的参数, 用于创建一个待插入unordered_multimap的元素

////返回值  指向新插入元素的迭代器。

//此函数的容器元素的引用是无效的，但是，它可能使容器内的所有迭代器都无效。

//

//value_type 一个元素是一对, 使元素值为一个有序对，第一个组件与键值相同和第二组件与元素数据值相同。

//

//在插入代码段时，如果异常被抛出，但没有出现在容器的哈希函数中，将不会修改容器。 如果在哈希函数引发异常，则结果是未定义的。

//

//有关代码示例，请参见 multimap::emplace。

//// multimap_emplace.cpp

//// compile with: /EHsc

//#include <map>

//#include <string>

//#include <iostream>

//

//using namespace std;

//

//template <typename M> void print(const M& m) {

//   cout << m.size() << " elements: " << endl;

//

//   for (const auto& p : m) {

//  cout << "(" << p.first << "," << p.second << ") ";

//   }

//

//   cout << endl;

//}

//

//int main()

//{

//   multimap<string, string> m1;

//

//   m1.emplace("Anna", "Accounting");

//   m1.emplace("Bob", "Accounting");

//   m1.emplace("Carmine", "Engineering");

//

//   cout << "multimap modified, now contains ";

//   print(m1);

//   cout << endl;

//

//   m1.emplace("Bob", "Engineering");

//

//   cout << "multimap modified, now contains ";

//   print(m1);

//   cout << endl;

//}

//

//

//

////unordered_multimap::emplace_hint添加就地构造的元素，附带提示。

////在适当的位置插入构造的元素(不执行复制或移动操作)，附带位置提示。

//template<class... Args>

//iterator emplace_hint(

//   const_iterator where,//where有关起始位置的提示搜索正确位置插入。

//   Args&&... args);//args传递的参数, 用于创建一个待插入无序的元素

//

//--返回值   指向新插入元素的迭代器。

//

//备注

//此函数的容器元素的引用是无效的，但是，它可能使容器内的所有迭代器都无效。

//

//在插入代码段时，如果异常被抛出，但没有出现在容器的哈希函数中，将不会修改容器。 如果在哈希函数引发异常，则结果是未定义的。

//

//value_type 一个元素是一对, 使元素值为一个有序对，第一个组件与键值相同和第二组件与元素数据值相同。

//

//有关代码示例，请参见 map::emplace_hint。

//// map_emplace.cpp

//// compile with: /EHsc

//#include <map>

//#include <string>

//#include <iostream>

//

//using namespace std;

//

//template <typename M> void print(const M& m) {

//   cout << m.size() << " elements: " << endl;

//

//   for (const auto& p : m) {

//  cout << "(" << p.first << "," << p.second << ") ";

//   }

//

//   cout << endl;

//}

//

//int main()

//{

//   map<string, string> m1;

//

//   // Emplace some test data

//   m1.emplace("Anna", "Accounting");

//   m1.emplace("Bob", "Accounting");

//   m1.emplace("Carmine", "Engineering");

//

//   cout << "map starting data: ";

//   print(m1);

//   cout << endl;

//

//   // Emplace with hint

//   // m1.end() should be the "next" element after this emplacement

//   m1.emplace_hint(m1.end(), "Doug", "Engineering");

//

//   cout << "map modified, now contains ";

//   print(m1);

//   cout << endl;

//}

//

//

//

//

////unordered_multimap::empty测试元素是否存在。

////bool empty() const;对于空受控序列，该成员函数返回 true。

//// std_tr1__unordered_map__unordered_multimap_empty.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // clear the container and reinspect 

//   c1.clear();

//   std::cout << "size == " << c1.size() << std::endl;

//   std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

//   std::cout << std::endl;

//

//   c1.insert(Mymap::value_type('d', 4));

//   c1.insert(Mymap::value_type('e', 5));

//

//   // display contents " [e 5] [d 4]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   std::cout << "size == " << c1.size() << std::endl;

//   std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

//

//   return (0);

//}

//

////unordered_multimap::end指定受控序列的末尾。

////iterator end();

////const_iterator end() const;

////local_iterator end(size_type nbucket);

////const_local_iterator end(size_type nbucket) const;//nbucket 存储桶编号。

//前两个成员函数返回一个向前迭代器，它指向刚超出序列末尾的位置。 最后两个成员函数返回一个向前迭代器，它指向刚超出存储桶 nbucket 末尾的位置。

//// std_tr1__unordered_map__unordered_multimap_end.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // inspect last two items " [a 1] [b 2]" 

//   Mymap::iterator it2 = c1.end();

//   --it2;

//   std::cout << " [" << it2->first << ", " << it2->second << "]";

//   --it2;

//   std::cout << " [" << it2->first << ", " << it2->second << "]";

//   std::cout << std::endl;

//

//   // inspect bucket containing 'a' 

//   Mymap::const_local_iterator lit = c1.end(c1.bucket('a'));

//   --lit;

//   std::cout << " [" << lit->first << ", " << lit->second << "]";

//

//   return (0);

//}

//

//

////unordered_multimap::equal_range查找与指定键匹配的范围。

//// 查找匹配指定密钥的范围。

//std::pair<iterator, iterator>

//equal_range(const Key& keyval);// keyval搜索的关键值

//std::pair<const_iterator, const_iterator>

//equal_range(const Key& keyval) const;

////这个函数返回一迭代器对x，[x.first，x.second）划只是那些元素的控制序列，具有相同的排序keyval。如果没有这样的元素存在，这两个迭代器是end（）。

//// 成员函数返回一对迭代器 X 这样 [X.first, X.second) 分离具有等效的顺序使用 keyval控制的元素序列。 如果不存在此类元素，则两个迭代器是 end()。

//

//

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // display results of failed search 

//   std::pair<Mymap::iterator, Mymap::iterator> pair1 =

//  c1.equal_range('x');

//   std::cout << "equal_range('x'):";

//   for (; pair1.first != pair1.second; ++pair1.first)

//  std::cout << " [" << pair1.first->first

//  << ", " << pair1.first->second << "]";

//   std::cout << std::endl;

//

//   // display results of successful search 

//   pair1 = c1.equal_range('b');

//   std::cout << "equal_range('b'):";

//   for (; pair1.first != pair1.second; ++pair1.first)

//  std::cout << " [" << pair1.first->first

//  << ", " << pair1.first->second << "]";

//   std::cout << std::endl;

//

//   return (0);

//}

////unordered_multimap::erase移除指定位置处的元素。

////从指定位置的非有序多重映射中移除一个元素或一定范围内的元映或移除与指定关键值匹配的元素。

//iterator erase(

//   const_iterator Where

//   );

//iterator erase(

//   const_iterator First,

//   const_iterator Last

//   );

//size_type erase(

//   const key_type& Key

//   );

//Where要移除的元素的位置。

//

//First要移除的第一个元素的位置。

//

//Last最后一个元素前面的要移除元素的位置。

//

//Key要移除元素的关键值。

//对于前两个成员函数，指定保持在所有元素外的第一个元素中移除一双向迭代器或如果不存在这样的元素设置为末尾的元素。

//

//为第三个成员函数，返回从集合中移除元素的数目。

//// map_erase.cpp

//// compile with: /EHsc

//#include <map>

//#include <string>

//#include <iostream>

//#include <iterator> // next() and prev() helper functions

//#include <utility>  // make_pair()

//

//using namespace std;

//

//using mymap = map<int, string>;

//

//void printmap(const mymap& m) {

//   for (const auto& elem : m) {

//  cout << " [" << elem.first << ", " << elem.second << "]";

//   }

//   cout << endl << "size() == " << m.size() << endl << endl;

//}

//

//int main()

//{

//   mymap m1;

//

//   // Fill in some data to test with, one at a time

//   m1.insert(make_pair(1, "A"));

//   m1.insert(make_pair(2, "B"));

//   m1.insert(make_pair(3, "C"));

//   m1.insert(make_pair(4, "D"));

//   m1.insert(make_pair(5, "E"));

//

//   cout << "Starting data of map m1 is:" << endl;

//   printmap(m1);

//   // The 1st member function removes an element at a given position

//   m1.erase(next(m1.begin()));

//   cout << "After the 2nd element is deleted, the map m1 is:" << endl;

//   printmap(m1);

//

//   // Fill in some data to test with, one at a time, using an intializer list

//   mymap m2

//   {

//  { 10, "Bob" },

//  { 11, "Rob" },

//  { 12, "Robert" },

//  { 13, "Bert" },

//  { 14, "Bobby" }

//   };

//

//   cout << "Starting data of map m2 is:" << endl;

//   printmap(m2);

//   // The 2nd member function removes elements

//   // in the range [First, Last)

//   m2.erase(next(m2.begin()), prev(m2.end()));

//   cout << "After the middle elements are deleted, the map m2 is:" << endl;

//   printmap(m2);

//

//   mymap m3;

//

//   // Fill in some data to test with, one at a time, using emplace

//   m3.emplace(1, "red");

//   m3.emplace(2, "yellow");

//   m3.emplace(3, "blue");

//   m3.emplace(4, "green");

//   m3.emplace(5, "orange");

//   m3.emplace(6, "purple");

//   m3.emplace(7, "pink");

//

//   cout << "Starting data of map m3 is:" << endl;

//   printmap(m3);

//   // The 3rd member function removes elements with a given Key

//   mymap::size_type count = m3.erase(2);

//   // The 3rd member function also returns the number of elements removed

//   cout << "The number of elements removed from m3 is: " << count << "." << endl;

//   cout << "After the element with a key of 2 is deleted, the map m3 is:" << endl;

//   printmap(m3);

//}

//

//

////unordered_multimap::find查找与指定键匹配的元素。

////const_iterator find(const Key& keyval) const;//keyval 搜索的键值。

//成员函数返回(keyval).first。 unordered_multimap::equal_range

//// std_tr1__unordered_map__unordered_multimap_find.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // try to find and fail 

//   std::cout << "find('A') == "

//  << std::boolalpha << (c1.find('A') != c1.end()) << std::endl;

//

//   // try to find and succeed 

//   Mymap::iterator it = c1.find('b');

//   std::cout << "find('b') == "

//  << std::boolalpha << (it != c1.end())

//  << ": [" << it->first << ", " << it->second << "]" << std::endl;

//

//   return (0);

//}

//

////unordered_multimap::get_allocator获取存储的分配器对象。

////Alloc get_allocator() const;成员函数返回存储的程序分配对象。

//// std_tr1__unordered_map__unordered_multimap_get_allocator.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//typedef std::allocator<std::pair<const char, int> > Myalloc;

//int main()

//{

//   Mymap c1;

//

//   Mymap::allocator_type al = c1.get_allocator();

//   std::cout << "al == std::allocator() is "

//  << std::boolalpha << (al == Myalloc()) << std::endl;

//

//   return (0);

//}

////unordered_multimap::hash_function获取存储的哈希函数对象。

////Hash hash_function() const;成员函数返回存储的哈希函数对象。

//// std_tr1__unordered_map__unordered_multimap_hash_function.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   Mymap::hasher hfn = c1.hash_function();

//   std::cout << "hfn('a') == " << hfn('a') << std::endl;

//   std::cout << "hfn('b') == " << hfn('b') << std::endl;

//

//   return (0);

//}

////unordered_multimap::insert添加元素。

////将一个元素或元素范围插入到 unordered_multimap 中。

//// (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 );

//参数

//描述

//

//Val

//要插入到 unordered_multimap 中的元素的值。

//

//Where

//开始搜索正确插入点的位置。

//

//ValTy

//指定 unordered_multimap 可用于构造 value_type 元素的参数类型并将 Val 作为参数完美转发的模板参数。

//

//First

//要复制的第一个元素的位置。

//

//Last

//要复制的最后一个元素以外的位置。

//

//InputIterator

//满足 输入迭代器要求的模板函数参数，该输入迭代器指向可用于构造 value_type 对象的类型的元素。

//

//IList

//从中复制元素的 initializer_list。

//单个元素插入成员函数(1) 和(2) 返回迭代器，该迭代器指向将新元素插入到 unordered_multimap 中的位置。

//

//附带提示的单个元素成员函数(3) 和(4) 返回迭代器，该迭代器指向将新元素插入到 unordered_multimap 中的位置。

//指针或引用不会因为此函数而失效，但是它可能会使所有指向容器的迭代器都失效。

//

//在只插入单个元素的过程中，如果引发异常，但是异常并未在容器的哈希函数中发生，则不会修改该容器的状态。 如果在哈希函数中引发异常，则未定义此结果。 在插入多个元素的过程中，如果引发异常，则会使容器处于未指定但有效的状态。

//

//容器的 value_type 是属于该容器的 typedef；对于映射，map<K, V>::value_type 是 pair<const K, V>。 元素的值是一个有序对，其中第一个组件相当于键值，第二个组件相当于该元素的数据值。

//

//范围成员函数(5) 将元素值序列插入到 unordered_multimap 中，它对应于迭代器在范围[First, Last) 中所处理的每一个元素；因此，不会插入 Last。 容器成员函数 end() 是指容器中最后一个元素之后的位置，例如，m.insert(v.begin(), v.end()); 语句会将 v 的所有元素插入到 m 中。

//

//初始值设定项列表成员函数(6) 使用 initializer_list 将元素复制到 unordered_multimap 中。

//

//有关就地构造的元素的插入（即不会执行复制或移动操作），请参阅 unordered_multimap::emplace 和 unordered_multimap::emplace_hint。

//

//有关代码示例，请参阅 multiset::insert。

//// multiset_insert.cpp

//// compile with: /EHsc

//#include <set>

//#include <iostream>

//#include <string>

//#include <vector>

//

//using namespace std;

//

//template <typename S> void print(const S& s) {

//   cout << s.size() << " elements: ";

//

//   for (const auto& p : s) {

//  cout << "(" << p << ") ";

//   }

//

//   cout << endl;

//}

//

//int main()

//{

//

//   // insert single values 

//   multiset<int> s1;

//   // call insert(const value_type&) version

//   s1.insert({ 1, 10 });

//   // call insert(ValTy&&) version 

//   s1.insert(20);

//

//   cout << "The original multiset values of s1 are:" << endl;

//   print(s1);

//

//   // intentionally attempt a duplicate, single element

//   s1.insert(1);

//   cout << "The modified multiset values of s1 are:" << endl;

//   print(s1);

//   cout << endl;

//

//   // single element, with hint

//   s1.insert(s1.end(), 30);

//   cout << "The modified multiset values of s1 are:" << endl;

//   print(s1);

//   cout << endl;

//

//

//   // The templatized version inserting a jumbled range

//   multiset<int> s2;

//   vector<int> v;

//   v.push_back(43);

//   v.push_back(294);

//   v.push_back(41);

//   v.push_back(330);

//   v.push_back(42);

//   v.push_back(45);

//

//   cout << "Inserting the following vector data into s2:" << endl;

//   print(v);

//

//   s2.insert(v.begin(), v.end());

//

//   cout << "The modified multiset values of s2 are:" << endl;

//   print(s2);

//   cout << endl;

//

//   // The templatized versions move-constructing elements

//   multiset<string>  s3;

//   string str1("blue"), str2("green");

//

//   // single element

//   s3.insert(move(str1));

//   cout << "After the first move insertion, s3 contains:" << endl;

//   print(s3);

//

//   // single element with hint

//   s3.insert(s3.end(), move(str2));

//   cout << "After the second move insertion, s3 contains:" << endl;

//   print(s3);

//   cout << endl;

//

//   multiset<int> s4;

//   // Insert the elements from an initializer_list

//   s4.insert({ 4, 44, 2, 22, 3, 33, 1, 11, 5, 55 });

//   cout << "After initializer_list insertion, s4 contains:" << endl;

//   print(s4);

//   cout << endl;

//}

//

//

//

//

////unordered_multimap::key_eq获取存储的比较函数对象。

////Pred key_eq() const;成员函数返回存储的比较函数对象。

//// std_tr1__unordered_map__unordered_multimap_key_eq.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   Mymap::key_equal cmpfn = c1.key_eq();

//   std::cout << "cmpfn('a', 'a') == "

//  << std::boolalpha << cmpfn('a', 'a') << std::endl;

//   std::cout << "cmpfn('a', 'b') == "

//  << std::boolalpha << cmpfn('a', 'b') << std::endl;

//

//   return (0);

//}

////unordered_multimap::load_factor对每个存储桶的平均元素数进行计数。

////float load_factor() const;

//成员函数() / (float)返回(float) unordered_multimap::size unordered_multimap::bucket_count，()元素的数量平均每个存储桶。

//这个函数返回（浮动）unordered_multimap：：size() / （浮动）unordered_multimap：：bucket_count()，每个桶中元素的平均数量

//// std_tr1__unordered_map__unordered_multimap_load_factor.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // inspect current parameters 

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_bucket_count() == "

//  << c1.max_bucket_count() << std::endl;

//   std::cout << "max_load_factor() == "

//  << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   // change max_load_factor and redisplay 

//   c1.max_load_factor(0.10f);

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_bucket_count() == "

//  << c1.max_bucket_count() << std::endl;

//   std::cout << "max_load_factor() == "

//  << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   // rehash and redisplay 

//   c1.rehash(100);

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_bucket_count() == "

//  << c1.max_bucket_count() << std::endl;

//   std::cout << "max_load_factor() == "

//  << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   return (0);

//}

//

////unordered_multimap::max_bucket_count获取最大的存储桶数。获取包含的最大项数。

////size_type max_bucket_count() const;成员函数返回当前存储桶中允许的最大次数。

//// std_tr1__unordered_map__unordered_multimap_max_bucket_count.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // inspect current parameters 

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_bucket_count() == "

//  << c1.max_bucket_count() << std::endl;

//   std::cout << "max_load_factor() == "

//  << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   // change max_load_factor and redisplay 

//   c1.max_load_factor(0.10f);

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_bucket_count() == "

//  << c1.max_bucket_count() << std::endl;

//   std::cout << "max_load_factor() == "

//  << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   // rehash and redisplay 

//   c1.rehash(100);

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_bucket_count() == "

//  << c1.max_bucket_count() << std::endl;

//   std::cout << "max_load_factor() == "

//  << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   return (0);

//}

//////////////////////////////////////////

////unordered_multimap::max_load_factor获取或设置每个存储桶的最多元素数。

//float max_load_factor() const;

//void max_load_factor(float factor);//factor 最大负载以便新的因素。

////第一成员函数返回存储的最大负载因子。二次成员函数替换了存储的最大负载因子。

//

//

//// std_tr1__unordered_map__unordered_multimap_max_bucket_count.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // inspect current parameters 

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_bucket_count() == "

//  << c1.max_bucket_count() << std::endl;

//   std::cout << "max_load_factor() == "

//  << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   // change max_load_factor and redisplay 

//   c1.max_load_factor(0.10f);

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_bucket_count() == "

//  << c1.max_bucket_count() << std::endl;

//   std::cout << "max_load_factor() == "

//  << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   // rehash and redisplay 

//   c1.rehash(100);

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_bucket_count() == "

//  << c1.max_bucket_count() << std::endl;

//   std::cout << "max_load_factor() == "

//  << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   return (0);

//}

//

////unordered_multimap::max_size获取受控序列的最大大小。

////size_type max_size() const;成员函数返回对象可以控制最长序列的长度

//// std_tr1__unordered_map__unordered_multimap_max_size.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   std::cout << "max_size() == " << c1.max_size() << std::endl;

//

//   return (0);

//}

////unordered_multimap::rehash重新生成哈希表。

////void rehash(size_type nbuckets);//nbuckets 请求的存储桶数。

////成员函数将存储桶数更改为至少 nbuckets并根据需要重新生成哈希表。

//// std_tr1__unordered_map__unordered_multimap_rehash.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // inspect current parameters 

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   // change max_load_factor and redisplay 

//   c1.max_load_factor(0.10f);

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;

//   std::cout << std::endl;

//

//   // rehash and redisplay 

//   c1.rehash(100);

//   std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;

//   std::cout << "load_factor() == " << c1.load_factor() << std::endl;

//   std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;

//

//   return (0);

//}

//

//

////unordered_multimap::size对元素数进行计数。

////计算元素的数量。

////size_type size() const;备注:成员函数返回控制序列的长度。

//// std_tr1__unordered_map__unordered_multimap_size.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   // clear the container and reinspect 

//   c1.clear();

//   std::cout << "size == " << c1.size() << std::endl;

//   std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

//   std::cout << std::endl;

//

//   c1.insert(Mymap::value_type('d', 4));

//   c1.insert(Mymap::value_type('e', 5));

//

//   // display contents " [e 5] [d 4]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   std::cout << "size == " << c1.size() << std::endl;

//   std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

//

//   return (0);

//}

//

////unordered_multimap::swap交换两个容器的内容。

////void swap(unordered_multimap& right);//right 交换的容器。

////成员函数将交换了 *this 和 right之间的控制序列。 unordered_multimap::get_allocator如果() == right.get_allocator()，在常数的时间执行，仅引发异常导致复制 Tr类型的对象存储字符，因此，它不在指定无效两个控制序列的元素的引用、指针或迭代器。 否则，它将执行大量的元素赋值，然后构造函数调用而与元素数目在两个控件的顺序。

//

//

//// std_tr1__unordered_map__unordered_multimap_swap.cpp 

//// compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//typedef std::unordered_multimap<char, int> Mymap;

//int main()

//{

//   Mymap c1;

//

//   c1.insert(Mymap::value_type('a', 1));

//   c1.insert(Mymap::value_type('b', 2));

//   c1.insert(Mymap::value_type('c', 3));

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   Mymap c2;

//

//   c2.insert(Mymap::value_type('d', 4));

//   c2.insert(Mymap::value_type('e', 5));

//   c2.insert(Mymap::value_type('f', 6));

//

//   c1.swap(c2);

//

//   // display contents " [f 6] [e 5] [d 4]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   swap(c1, c2);

//

//   // display contents " [c 3] [b 2] [a 1]" 

//   for (Mymap::const_iterator it = c1.begin();

//   it != c1.end(); ++it)

//  std::cout << " [" << it->first << ", " << it->second << "]";

//   std::cout << std::endl;

//

//   return (0);

//}

////unordered_multimap::unordered_multimap构造容器对象。

////unordered_multimap(

//    const unordered_multimap& Right

//   );

//   explicit unordered_multimap(

//  size_type Bucket_count = N0,

//  const Hash& Hash = Hash(),

//  const Comp& Comp = Pred(),

//  const Allocator& Al = Alloc()

//  );

//   unordered_multimap(

//  unordered_multimap&& Right

//  );

//   unordered_multimap(

//  initializer_list<Type> IList

//  );

//   unordered_multimap(

//  initializer_list< Type > IList,

//  size_type Bucket_count

//  );

//   unordered_multimap(

//  initializer_list< Type > IList,

//  size_type Bucket_count,

//  const Hash& Hash

//  );

//   unordered_multimap(

//  initializer_list< Type > IList,

//  size_type Bucket_count,

//  const Hash& Hash,

//  const Key& Key

//  );

//   unordered_multimap(

//  initializer_list<Type> IList,

//  size_type Bucket_count,

//  const Hash& Hash,

//  const Key& Key,

//  const Allocator& Al

//  );

//   template<class InputIterator>

//   unordered_multimap(

//  InputIterator first,

//  InputIterator last,

//  size_type Bucket_count = N0,

//  const Hash& Hash = Hash(),

//  const Comp& Comp = Pred(),

//  const Allocator& Al = Alloc()

//  );

//   InputIterator  迭代器类型。

//

//  Al  要存储的分配器对象。

//

//  Comp  要存储的比较函数对象。

//

//  Hash  要存储的哈希函数对象。

//

//  Bucket_count  存储桶的最少数量。

//

//  Right  要复制的容器。

//

//  IList  从中复制元素的 initializer_list。

//

//  第一个构造函数指定通过 Right 控制的序列副本。 第二个构造函数指定空的受控序列。 第三个构造函数。 通过移动 Right 指定序列副本。 第四、第五、第六、第七和第八个构造函数对成员使用 initializer_list。 第九个构造函数插入元素值[First, Last) 的序列。

//

//  所有构造函数还初始化若干存储的值。 对于复制构造函数，值从 Right 获取。 否则：

//

//  存储桶的最少数量是参数 Bucket_count（如果有）；否则为此处说明的默认值 N0。

//

//  哈希函数对象是参数 Hash（如果有）；否则为 Hash()。

//

//  比较函数对象是参数 Comp（如果有）；否则为 Pred()。

//

//  分配器对象是参数 Al（如果有）；否则为 Alloc()。

//

//  // std__unordered_map__unordered_multimap_construct.cpp 

//  // compile with: /EHsc 

//#include <unordered_map> 

//#include <iostream> 

//

//  using namespace std;

//

//   using  Mymap = unordered_multimap<char, int>;

//   int main()

//   {

//  Mymap c1;

//

//  c1.insert(Mymap::value_type('a', 1));

//  c1.insert(Mymap::value_type('b', 2));

//  c1.insert(Mymap::value_type('c', 3));

//

//  // display contents " [c 3] [b 2] [a 1]" 

//  for (const auto& c : c1) {

// cout << " [" << c.first << ", " << c.second << "]";

//  }

//  cout << endl;

//

//

//  Mymap c2(8,

// hash<char>(),

// equal_to<char>(),

// allocator<pair<const char, int> >());

//

//  c2.insert(Mymap::value_type('d', 4));

//  c2.insert(Mymap::value_type('e', 5));

//  c2.insert(Mymap::value_type('f', 6));

//

//  // display contents " [f 6] [e 5] [d 4]" 

//  for (const auto& c : c2) {

// cout << " [" << c.first << ", " << c.second << "]";

//  }

//  cout << endl;

//

//  Mymap c3(c1.begin(),

// c1.end(),

// 8,

// hash<char>(),

// equal_to<char>(),

// allocator<pair<const char, int> >());

//

//  // display contents " [c 3] [b 2] [a 1]" 

//  for (const auto& c : c3) {

// cout << " [" << c.first << ", " << c.second << "]";

//  }

//  cout << endl;

//

//  Mymap c4(move(c3));

//

//  // display contents " [c 3] [b 2] [a 1]" 

//  for (const auto& c : c4) {

// cout << " [" << c.first << ", " << c.second << "]";

//  }

//  cout << endl;

//

//  // Construct with an initializer_list

//  unordered_multimap<int, char> c5({ { 5, 'g' },{ 6, 'h' },{ 7, 'i' },{ 8, 'j' } });

//  for (const auto& c : c5) {

// cout << " [" << c.first << ", " << c.second << "]";

//  }

//  cout << endl;

//

//  // Initializer_list plus size

//  unordered_multimap<int, char> c6({ { 5, 'g' },{ 6, 'h' },{ 7, 'i' },{ 8, 'j' } }, 4);

//  for (const auto& c : c1) {

// cout << " [" << c.first << ", " << c.second << "]";

//  }

//  cout << endl;

//

//  // Initializer_list plus size and hash

//  unordered_multimap<int, char, tr1::hash<char>> c7(

//  { { 5, 'g' },{ 6, 'h' },{ 7, 'i' },{ 8, 'j' } },

// 4,

// tr1::hash<char>()

// );

//

//  for (const auto& c : c1) {

// cout << " [" << c.first << ", " << c.second << "]";

//  }

//  cout << endl;

//

//  // Initializer_list plus size, hash, and key_equal

//  unordered_multimap<int, char, tr1::hash<char>, equal_to<char>> c8(

//  { { 5, 'g' },{ 6, 'h' },{ 7, 'i' },{ 8, 'j' } },

// 4,

// tr1::hash<char>(),

// equal_to<char>()

// );

//

//  for (const auto& c : c1) {

// cout << " [" << c.first << ", " << c.second << "]";

//  }

//  cout << endl;

//

//  // Initializer_list plus size, hash, key_equal, and allocator

//  unordered_multimap<int, char, tr1::hash<char>, equal_to<char>> c9(

//  { { 5, 'g' },{ 6, 'h' },{ 7, 'i' },{ 8, 'j' } },

// 4,

// tr1::hash<char>(),

// equal_to<char>(),

// allocator<pair<const char, int> >()

// );

//

//  for (const auto& c : c1) {

// cout << " [" << c.first << ", " << c.second << "]";

//  }

//  cout << endl;

//   }

////

////运算符说明

////

////unordered_multimap::operator=  复制哈希表。

//   unordered_multimap& operator=(

//  const unordered_multimap& _Right

//  );

//   unordered_multimap& operator=(

//  unordered_multimap&& _Right

//  );

//   _Right

//  正在被复制到 unordered_multimap 中的 unordered_multimap。

//  在清除 unordered_multimap 中的任何现有元素后，operator = 会将 _Right 的内容复制或移动到 unordered_multimap 中。

//  // unordered_multimap_operator_as.cpp

//  // compile with: /EHsc

//#include <unordered_multimap>

//#include <iostream>

//

//  int main()

//   {

//  using namespace std;

//  unordered_multimap<int, int> v1, v2, v3;

//  unordered_multimap<int, int>::iterator iter;

//

//  v1.insert(pair<int, int>(1, 10));

//

//  cout << "v1 = ";

//  for (iter = v1.begin(); iter != v1.end(); iter++)

// cout << iter->second << " ";

//  cout << endl;

//

//  v2 = v1;

//  cout << "v2 = ";

//  for (iter = v2.begin(); iter != v2.end(); iter++)

// cout << iter->second << " ";

//  cout << endl;

//

//  // move v1 into v2

//  v2.clear();

//  v2 = move(v1);

//  cout << "v2 = ";

//  for (iter = v2.begin(); iter != v2.end(); iter++)

// cout << iter->second << " ";

//  cout << endl;

//   }

//