C++进阶 —— multimap

目录

一，multimap介绍

 类pair

函数模板make_pair

二，multimap成员函数

---

一，multimap介绍

• multimap是关联容器，按照特定的次序存储元素（由键key和值value组合而成的键值对），key可重复；
  • 键key通常用于排序及唯一标识元素，而值value则存储与键key关联的内容；
  • 键key和值value的类型可能不同，且在map的内部，key与value通过成员类型value_type绑定在一起；
  • key是唯一的，并且不能修改；
  • map中的元素如用迭代器去遍历，可以得到一个有序序列；

typedef pair<const Key, T> value_type;

• multimap中的元素始终根据其key按照其内部比较对象(compare)所指示的特定严格弱排序准则进行排序；
• multimap通过key访问元素的速度通常比unordered_multimap容器慢，但使用迭代器直接遍历multimap中的元素可以得到关于key的有序序列；
• multimap通常被实现为二叉搜索树(红黑树)，查找效率比较高O(logN)；

注：multimap与map唯一不同就是，map中key是唯一的，multimap中key是可以重复的；

 类pair

template <class T1, class T2> struct pair;

• 此类将一对值组合在一起，类型可以不同；
• 可直接访问其公共成员变量first、second；
• pair是tuple的特殊形式；

std::pair<int, double> p1(1, 2.5); //initialization (3) 初始化构造
std::pair<long, float> p2(p1);    //copy/move (2) 调用模板拷贝构造函数，会进行类型转换
std::pair<long, float> p3(std::move(p1)); //copy/move (2) 调用模板移动构造函数，会进行类型转换
std::pair<int, double> p4(p1);    //copy/move (2) 调用默认拷贝构造函数
std::pair<int, double> p5(std::move(p1)); //copy/move (2) 调用默认移动构造函数

函数模板make_pair

• 构建一个pair对象，第一个元素为x，第二个元素为y；
• 通过传递的参数可隐式的推导模板类型；

template <class T1, class T2>
  pair<V1,V2> make_pair (T1&& x, T2&& y);

//此函数返回，初始化构造一个pair对象，对参数进行完美转发
  pair<V1,V2>(std::forward<T1>(x),std::forward<T2>(y))

//自动推导类型，不需要显式指定类型
auto p1 = std::make_pair(1, "hello");        // pair<int, const char*>
auto p2 = std::make_pair(3.14, true);        // pair<double, bool>

//隐式转化 pair<double,char>
std::pair <int, int> bar;
bar = std::make_pair(10.5, 'A'); 

//完美转发
string str = "world";
auto p3 = std::make_pair(std::move(str), 42); // 移动语义，str 被转移

二，multimap成员函数

• multimap中key是可以重复的；
• multimap中的元素默认将key按照小于来比较；
• multimap中没有重载operator[]操作；

构造函数

操作函数

//迭代器
      iterator begin() noexcept;
const_iterator begin() const noexcept;
      iterator end() noexcept;
const_iterator end() const noexcept;
      reverse_iterator rbegin() nothrow;
const_reverse_iterator rbegin() const nothrow;
      reverse_iterator rend() nothrow;
const_reverse_iterator rend() const nothrow;

//插入
single element (1)	
    iterator insert (const value_type& val);
    template <class P> iterator insert (P&& val);
with hint (2)	
    iterator insert (const_iterator position, const value_type& val);
    template <class P> iterator insert (const_iterator position, P&& val);
range (3)	
    template <class InputIterator>
    void insert (InputIterator first, InputIterator last);
initializer list (4)	
    void insert (initializer_list<value_type> il);

//删除	
iterator  erase (const_iterator position);
size_type erase (const key_type& k);
iterator  erase (const_iterator first, const_iterator last);

//查找
      iterator find (const key_type& k);
const_iterator find (const key_type& k) const;

bool empty() const noexcept;
size_type size() const noexcept;
size_type count (const key_type& k) const;
void swap (multimap& x);
void clear() noexcept;

key_compare key_comp() const;
value_compare value_comp() const;

      iterator lower_bound (const key_type& k);
const_iterator lower_bound (const key_type& k) const;
      iterator upper_bound (const key_type& k);
const_iterator upper_bound (const key_type& k) const;

pair<const_iterator,const_iterator> equal_range (const key_type& k) const;
            pair<iterator,iterator> equal_range (const key_type& k);

int main()
{
	multimap<string, string> m;
	
	m.insert(pair<string, string>("peach", "桃子")); 
	m.insert(make_pair("banan", "香蕉"));
	m.insert(make_pair("banan", "香蕉"));
	cout << m.size() << endl;
	cout << m.count("banan") << endl;

	for (auto& e : m)
	{
		cout << e.first << "-->" << e.second << endl;
	}

	m.erase("banan");

	multimap<string, string>::iterator it = m.begin();
	while (it != m.end())
	{
		cout << (*it).first << "-->" << (*it).second << endl;
		++it;
	}

	it = m.find("peach");
	cout << (*it).first << "-->" << (*it).second << endl;
	return 0;
}