map クラス

[機能]

　　連想配列，つまり，添え字として数値以外(キー)を使用してデータを参照できる配列を保持します．set と同様，一般的に二分木として実装され，データは自動的にソートされます．Comp に対しては，比較を行う二項関数オブジェクト名を指定します．指定しないと less （昇順）が選択されます．なお，以下に示す関数において，一般に，insert よりも，emplace を使ったほうが処理効率は良くなります．

template <class Key, class T, class Comp = less<Key>,
class Allocator = allocator<pair<const Key, T>>>
   class map		

[使用方法]

#include <map>
using namespace std;
map <Key, T> 変数名;
   map<int, string> x;   // 空の map，昇順
   map<int, string, greater<int>> x;   // 空の map，降順
   map<int, string> x(it1, it2);   // it1 から it2 の範囲で初期化
   map<int, string> x(y);   // map y で初期化
   map<int, string> x ({{1, "abc"}, {2, "efg"}});   // 初期化子リスト，C++11
   map<int, string> x {{1, "abc"}, {2, "efg"}};   // 初期化子リスト，C++11
   map<int, string> x = {{1, "abc"}, {2, "efg"}};   // 初期化子リスト，C++11		

[メンバー関数等]

• T& at(const key_type& x)
  指定したキーを持つ要素を取得する

• iterator begin()
  最初の要素を指すイテレータを返す

• const_iterator cbegin() // C++11
  先頭要素を指す読み取り専用イテレータ

• const_iterator cend() // C++11
  末尾の1つ次の要素を指す読み取り専用イテレータ

• void clear()
  すべての要素を削除する

• size_type count(const key_type& x)
  キー x を検索し，コンテナ内に見つかった要素の数を返す

• const_iterator crbegin() // C++11
  末尾の要素を指す読み取り専用逆イテレータ

• const_iterator crend() // C++11
  先頭の1つ前の要素を指す読み取り専用逆イテレータ

• template <class... Args> pair<iterator, bool> emplace(Args&&... args) // C++11
  コンテナに新しい要素を直接構築し挿入する（コピーもムーブもされない）．iterator には新しく挿入された要素またはすでに格納されていた要素を指すイテレータが設定され，また，bool には，要素が挿入されたときに true，同じ値の存在のため挿入されなかった場合には false が設定される．また，以下の 2 行目に示すように，ペアーを自動的に生成するような処理も可能である（ insert との違いに注意）．

  	map<int, string> mp {{1, "abc"}, {3, "efg"}};
  	mp.emplace(0, "xxx");
  	mp.emplace(make_pair(4, "yyy"));
  	mp.insert(make_pair(2, "xyz"));
  	for (auto x : mp)
  		cout << " (" << x.first << ", " << x.second << ")";
  	cout << endl;			

• template <class... Args> iterator emplace_hint(const_iterator hint, Args&&... args) // C++11
  要素が配置されるべき場所を示唆するパラメータ hint を使って（例えば，マップの先頭に挿入される可能性が高い場合は，begin() などを指定する），コンテナに新しい要素を直接構築して挿入する（コピーもムーブもされない）．

• bool empty()
  コンテナが空か否かを返す

• iterator end()
  最後の要素の次を指すイテレータを返す

• pair<iterator, iterator> equal_range(const key_type &k)
  指定されたキーに対応する範囲の上限と下限（ iterator の first と second ）を返す

• void erase(iterator it)
• iterator erase(const_iterator it) // C++11
  イテレータ it が指す場所の要素を削除し，次の要素に対するイテレータを返す．

• void erase(iterator start, iterator end)
• iterator erase(const_iterator start, const_iterator end) // C++11
  start から end までの要素を削除し，次の要素に対するイテレータを返す．

• size_type erase(const key_type &k)
  キーの値が k である要素を削除し，削除された要素の数を返す

• iterator find(const key_type& x)
  キーが x に等しい要素に対応するイテレータを返す

• allocate_type get_allocator()
  アロケータを返す

• pair<iterator, bool> insert(const value_type& x)
• iterator insert(const_iterator it, const value_type& x)
  （イテレータ it が指す場所の前に） pair 型オブジェクトである要素 x を挿入する．iterator には新しく挿入された要素またはすでに格納されていた要素を指すイテレータが設定され，また，bool には，要素が挿入されたときに true，同じ値の存在のため挿入されなかった場合には false が設定される．

• template <class InputIterator> void insert(InputIterator first, InputIterator last)
  範囲 [first, last) を挿入する

• void insert(initializer_list<value_type> init) // C++11
  初期化子リストを挿入する

• template <class M> pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj) // C++17
• template <class M> iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj) // C++17
  引数 k で指定されたキーが存在した場合は，対応する値を obj に変更し，その要素を示すイテレータと共に false を返す．存在しなかった場合はキーと対応する値 obj のペアーをマップに挿入し，その要素を示すイテレータと共に true を返す．引数 hint は，k を検索する際のヒントに使用される．例えば，マップの先頭に挿入される可能性が高い場合は，begin() などを指定する．

• iterator lower_bound(const key_type& x)
  キーの値が x 以上である最初の要素に対応するイテレータを返す

• size_type max_size()
  格納できる最大の要素数を返す

• template<class C2> void merge(map& m) // C++17
  引数 m 内の各要素を調べ，等価なキーを持つ要素がない場合はその要素を挿入する（要素はコピーもムーブもされない）．

• reverse_iterator rbegin()
  最後の要素を指す逆イテレータを返す

• reverse_iterator rend()
  最初の要素の 1 つ前を指す逆イテレータを返す

• size_type size()
  要素数を返す

• void swap(map<Key, T, Compare,Allocator> &m)
  2 つのコンテナの内容を入れ替える

• template <class... Args> pair<iterator, bool> try_emplace(const key_type& k, Args&&... args) // C++17
• template <class... Args> iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args) // C++17
  引数 k と等価のキーを持つ要素が存在しない場合，コンテナに新しい要素を直接構築して挿入する（コピーもムーブもされない）．その際，挿入された要素へのイテレータ，及び，true が返される．存在した場合は，何も実行せず，既存の要素へのイテレータ，及び，false が返される．引数 hint は，k を検索する際のヒントに使用される．例えば，マップの先頭に挿入される可能性が高い場合は，begin() などを指定する．

• iterator upper_bound(const key_type& x)
  キーの値が x より大きい最初の要素に対応するイテレータを返す

[演算子の多重定義]

=  ==  <  <=  !=  >  >=  []		

[使用例]

1. map の使用方法です．以下に示すプログラム例において，いくつかのコメント部分は，その上または下に記述された方法とほぼ同等なものであることを示しています（複数行の対応関係である場合もある）．

   #include <iostream>
   #include <map>
   
   using namespace std;
   
   void print(string str, map<string, int, greater<string>> &m) {
   	if (m.empty())
   		cout << "  コンテナ " << str << " は空です\n";
   	else {
   		cout << str << " の要素数： " << m.size() << endl;
   		for (auto x : m)
   			cout << "  " << x.first << " " << x.second;
   //		map<string, int, greater<string>>::iterator it;
   //		for (it = m.begin(); it != m.end(); it++)
   //			cout << "  " << (*it).first << " " << (*it).second;
   		cout << endl;
   	}
   }
   
   int main()
   {
   					// 要素を追加（サイズは自動的に増加）
   					// キーが string，値が int，大きい順にソート
   	cout << "**初期設定**\n";
   	map<string, int, greater<string>> m1;   // 二項関数オブジェクト greater
   	m1.insert(pair<string, int>("suzuki", 40));
   	m1.insert(pair<string, int>("sato", 60));
   	m1.insert(pair<string, int>("yamada", 70));
   	m1.insert(pair<string, int>("tanaka", 50));
   	m1.insert(pair<string, int>("kato", 90));
   	print("m1", m1);
   					// 2 番目の要素の前に要素を追加
   	cout << "**2 番目の要素の前に要素を追加**\n";
   	map<string, int, greater<string>>::iterator it = m1.begin();
   	it++;
   	m1.insert(it, pair<string, int>("naito", 20));
   	print("m1", m1);
   					// 2 番目の要素，及び，要素 sato を削除
   	cout << "**2 番目の要素，及び，要素 sato を削除**\n";
   	it = m1.begin();
   	it++;
   	m1.erase(it);
   	m1.erase("sato");
   	print("m1", m1);
   					// キー suzuki の値
   	cout << "**キー suzuki の値**\n";
   	it = m1.find("suzuki");
   	cout << "  値： " << it->second << endl;
   	cout << "  値： " << m1.at("suzuki") << endl;
   	cout << "  値： " << m1["suzuki"] << endl;
   					// 演算子で比較
   	cout << "**比較**\n";
   	map<string, int, greater<string>> m2 = {{"naito", 20}, {"suzuki", 40},
   	                                        {"yamada", 70}, {"kato", 90}};
   	print("m2", m2);
   	if (m1 == m2)
   		cout << "  2 つのコンテナ内の要素はすべて等しい\n";
   					// ヒントと insert_or_assign，try_emplace
   	cout << "ヒントと insert_or_assign\n";
   	m1.emplace_hint(m1.begin(), "wada", 10);   // 先頭近傍に挿入されることが既知
   	print("m1", m1);
   	pair<map<string, int, greater<string>>::iterator, bool> p;
   	p = m1.insert_or_assign("wada", 20);
   	cout << "存在した場合(insert_or_assign) " << (*p.first).second << " " << p.second << " ";
   	print("m1", m1);
   	p = m1.try_emplace("wada", 100);
   	cout << "存在した場合(try_emplace) " << (*p.first).second << " " << p.second << " ";
   	print("m1", m1);
   	p = m1.insert_or_assign("aoki", 50);
   	cout << "存在しなかったた場合(insert_or_assign) " << (*p.first).second << " " << p.second << " ";
   	print("m1", m1);
   					// [] 演算子（ ["tanaka"] ）
   	cout << "**[] 演算子（ [\"tanaka\"] ）**\n";
   	cout << m1["tanaka"] << endl;   // 参照した時点で追加される
   //	cout << m1.at("tanaka") << endl;   // キーが存在しないときは out_of_range 例外	print("m1", m1);
   	m1["tanaka"] = 100;
   	print("m1", m1);
   					// 交換
   	cout << "**交換**\n";
   	print("入れ替え前:m1", m1);
   	print("入れ替え前:m2", m2);
   	m1.swap(m2);
   	print("m1", m1);
   	print("m2", m2);
   					// m1 のすべての要素を削除
   	cout << "**m1 のすべての要素を削除**\n";
   	m1.clear();
   	print("m1", m1);
   
   	return 0;
   }
   			

   （出力）

   **初期設定**
   m1 の要素数： 5
     yamada 70  tanaka 50  suzuki 40  sato 60  kato 90
   **2 番目の要素の前に要素を追加**
   m1 の要素数： 6
     yamada 70  tanaka 50  suzuki 40  sato 60  naito 20  kato 90
   **2 番目の要素，及び，要素 sato を削除**
   m1 の要素数： 4
     yamada 70  suzuki 40  naito 20  kato 90
   **キー suzuki の値**
     値： 40
     値： 40
     値： 40
   **比較**
   m2 の要素数： 4
     yamada 70  suzuki 40  naito 20  kato 90
     2 つのコンテナ内の要素はすべて等しい
   ヒントと insert_or_assign
   m1 の要素数： 5
     yamada 70  wada 10  suzuki 40  naito 20  kato 90
   存在した場合(insert_or_assign) 20 0 m1 の要素数： 5
     yamada 70  wada 20  suzuki 40  naito 20  kato 90
   存在した場合(try_emplace) 20 0 m1 の要素数： 5
     yamada 70  wada 20  suzuki 40  naito 20  kato 90
   存在しなかったた場合(insert_or_assign) 50 1 m1 の要素数： 6
     yamada 70  wada 20  suzuki 40  naito 20  kato 90  aoki 50
   **[] 演算子（ ["tanaka"] ）**
   0
   m1 の要素数： 7
     yamada 70  wada 20  tanaka 100  suzuki 40  naito 20  kato 90  aoki 50
   **交換**
   入れ替え前:m1 の要素数： 7
     yamada 70  wada 20  tanaka 100  suzuki 40  naito 20  kato 90  aoki 50
   入れ替え前:m2 の要素数： 4
     yamada 70  suzuki 40  naito 20  kato 90
   m1 の要素数： 4
     yamada 70  suzuki 40  naito 20  kato 90
   m2 の要素数： 7
     yamada 70  wada 20  tanaka 100  suzuki 40  naito 20  kato 90  aoki 50
   **m1 のすべての要素を削除**
     コンテナ m1 は空です
   			

   map の使用方法です．クラス Test における整数値の和が大きい順にソートしています．コメントとして記述してあるように，比較演算子のオーバーロード（多重定義）を行えば，二項関数オブジェクトを定義しなくても構いません．

   #include <iostream>
   #include <map>
   #include <string>
   
   using namespace std;
   
   class Test {
   	public:
   		int n1, n2;
   		Test (const int& m1, const int& m2) {
   			n1 = m1;
   			n2 = m2;
   		}
   };
   			// 二項関数オブジェクト
   			// const は，関数内でメンバ変数の変更ができないことを意味する
   class GT
   {
   	public:
   		bool operator() (Test t1, Test t2) const
   		{
   			return (t1.n1+t1.n2 > t2.n1+t2.n2) ? true : false;
   		}
   };
   			// < 演算子のオーバーロード
   //bool operator< (Test t1, Test t2)
   //{
   //	return (t1.n1+t1.n2 > t2.n1+t2.n2) ? true : false;
   //}
   
   int main()
   {
   	Test t1(20, 30), t2(30, 10), t3(40, 50), t4(10, 10), t5(30, 30), t6(20, 30);
   	map<Test, string, GT> s1;   // 二項関数オブジェクト
   //	map<Test, string> s1;   // < 演算子のオーバーロード（多重定義）
   			// 初期状態 s1
   	s1.insert(pair<Test, string>(t1, "abc"));
   	s1.insert(pair<Test, string>(t2, "kkk"));
   	s1.insert(pair<Test, string>(t2, "kkk"));
   	s1.insert(pair<Test, string>(t3, "xyz"));
   	cout << "初期状態 s1\n";
   	for (auto x : s1)
   		cout << " (" << (x.first).n1 << ", " << (x.first).n2 << ") " << x.second << endl;
   			// 初期状態 s2
   	map<Test, string, GT> s2 = {{t4, "aaa"}, {t5, "bbb"}, {t6, "ccc"}};   // 二項関数オブジェクト
   //	map<Test, string> s2 = {{t4, "aaa"}, {t5, "bbb"}, {t6, "ccc"}};   // < 演算子のオーバーロード
   	cout << "初期状態 s2\n";
   	for (auto x : s2)
   		cout << " (" << (x.first).n1 << ", " << (x.first).n2 << ") " << x.second << endl;
   			// merge
   	s1.merge(s2);
   	cout << "merge 後 s1\n";
   	for (auto x : s1)
   		cout << " (" << (x.first).n1 << ", " << (x.first).n2 << ") " << x.second << endl;
   	cout << "merge 後 s2\n";
   	for (auto x : s2)
   		cout << " (" << (x.first).n1 << ", " << (x.first).n2 << ") " << x.second << endl;
   
   	return 0;
   }
   			

   （出力）

   初期状態 s1
    (40, 50) xyz
    (20, 30) abc
    (30, 10) kkk
   初期状態 s2
    (30, 30) bbb
    (20, 30) ccc
    (10, 10) aaa
   merge 後 s1
    (40, 50) xyz
    (30, 30) bbb
    (20, 30) abc
    (30, 10) kkk
    (10, 10) aaa
   merge 後 s2
    (20, 30) ccc
   			

[参照]

vector， set， multimap， array， forward_list， list， multiset， priority_queue， queue， stack， deque， unordered_map， unordered_multimap， unordered_set， unordered_multiset