[C++]STL之map
map<Key, Data, Compare, Alloc>
map是一种关联容器，存储相结合形成的一个关键值和映射值的元素。Map 是一种Pair Associative Container，意味着它的值类型为 pair<const Key, Data>. 而且也是 Unique Associative Container, 也就是任何两个元素没有相同的key值。
map具有重要的属性，就是在map对象中插入一个新元素不指向现有元素的迭代器失效。从map上删除一个元素，也没有任何迭代器失效，除非，当然，实际上指向正在被删除的元素的迭代器。
eg.
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;
}
定义形式
template < class Key, class T, class Compare = less<Key>,
class Allocator = allocator<pair<const Key,T> > > class map;
模板参数：
key ： 关键 值 的 类型 。 在map对象中 的 每个 元素 是通过该关键值唯一 确定元素的 。
T： 映射值 的 类型 。 在map中 的 每个 元素 是用来储存 一些数据 作为 其映射 值 。
compare： Comparison 类 ： A类 键的类型 ，它有两个 参数，并返回 一个bool 。 表达 comp （ A，B ） ， comp 是 这比较 类 A和B 是关键 值 的 对象 ， 应 返回true， 如果 是 在 早先的立场 比B 放置在 一个 严格弱 排序操作 。 这 可以是 一个 类实现 一个 函数调用运算符 或 一个函数 的 指针 （见 一个例子 构造 ） 。 默认的对于 <KEY> ， 返回 申请 小于操作符 相同 的 默认值（ A <B ）。
Map对象 使用 这个 表达式来确定 在容器中 元素 的 位置 。 以下 这个 规则 在任何时候都 排列 在 map 容器 中 的所有元素 。
Allocator ： 用于 定义 存储分配 模型 分配器对象 的 类型 。 默认情况下， 分配器 类模板 ， 它定义了 最简单 的 内存分配 模式 ，是 值独立的
map<Key,T>::iterator it; (*it).first; // 指向key值(of type Key) (*it).second; // 映射的值(of type T) (*it); // the "element value" (of type pair<const Key,T>)
也可以如下表达：
it->first; // same as (*it).first (the key value) it->second; // same as (*it).second (the mapped value)
成员变量和成员函数
| Member | Where defined | Description |
|---|---|---|
| key_type | Associative Container | map中的key类型 |
| data_type | Pair Associative Container | key关联的值类型 |
| value_type | Pair Associative Container | 对象类型, pair<const key_type, data_type>,存储在map中 |
| key_compare | Sorted Associative Container | Function object 通过顺序比较 |
| value_compare | Sorted Associative Container | Function object that compares two values for ordering. |
| pointer | Container | Pointer to T. |
| reference | Container | Reference to T |
| const_reference | Container | Const reference to T |
| size_type | Container | An unsigned integral type. |
| difference_type | Container | A signed integral type. |
| iterator | Container | Iterator used to iterate through a map. [1] |
| const_iterator | Container | Const iterator used to iterate through a map. |
| reverse_iterator | Reversible Container | Iterator used to iterate backwards through a map.[1] |
| const_reverse_iterator | Reversible Container | Const iterator used to iterate backwards through amap. |
| iterator begin() | Container | Returns an iterator pointing to the beginning of the map. |
| iterator end() | Container | Returns an iterator pointing to the end of themap. |
| const_iterator begin() const | Container | Returns a const_iterator pointing to the beginning of themap. |
| const_iterator end() const | Container | Returns a const_iterator pointing to the end of the map. |
| reverse_iterator rbegin() | Reversible Container | Returns a reverse_iterator pointing to the beginning of the reversed map. |
| reverse_iterator rend() | Reversible Container | Returns a reverse_iterator pointing to the end of the reversed map. |
| const_reverse_iterator rbegin() const | Reversible Container | Returns a const_reverse_iterator pointing to the beginning of the reversed map. |
| const_reverse_iterator rend() const | Reversible Container | Returns a const_reverse_iterator pointing to the end of the reversed map. |
| size_type size() const | Container | Returns the size of the map. |
| size_type max_size() const | Container | Returns the largest possible size of the map. |
| bool empty() const | Container | true if the map's size is 0. |
| key_compare key_comp() const | Sorted Associative Container | Returns the key_compare object used by the map. |
| value_compare value_comp() const | Sorted Associative Container | Returns the value_compare object used by themap. |
| map() | Container | Creates an empty map. |
| map(const key_compare& comp) | Sorted Associative Container | Creates an empty map, using comp as thekey_compare object. |
template <class InputIterator> map(InputIterator f, InputIterator l) |
Unique Sorted Associative Container | Creates a map with a copy of a range. |
template <class InputIterator>
map(InputIterator f, InputIterator l,
const key_compare& comp)
|
Unique Sorted Associative Container | Creates a map with a copy of a range, using compas thekey_compare object. |
| map(const map&) | Container | The copy constructor. |
| map& operator=(const map&) | Container | The assignment operator |
| void swap(map&) | Container | Swaps the contents of two maps. |
pair<iterator, bool> insert(const value_type& x) |
Unique Associative Container | Inserts x into the map. |
iterator insert(iterator pos,
const value_type& x)
|
Unique Sorted Associative Container | Inserts x into the map, using pos as a hint to where it will be inserted. |
template <class InputIterator> void insert(InputIterator, InputIterator) [2] |
Unique Sorted Associative Container | Inserts a range into the map. |
| void erase(iterator pos) | Associative Container | Erases the element pointed to by pos. |
| size_type erase(const key_type& k) | Associative Container | Erases the element whose key is k. |
| void erase(iterator first, iterator last) | Associative Container | Erases all elements in a range. |
| void clear() | Associative Container | Erases all of the elements. |
| iterator find(const key_type& k) | Associative Container | Finds an element whose key is k. |
| const_iterator find(const key_type& k) const | Associative Container | Finds an element whose key is k. |
| size_type count(const key_type& k) | Unique Associative Container | Counts the number of elements whose key is k. |
| iterator lower_bound(const key_type& k) | Sorted Associative Container | Finds the first element whose key is not less thank. |
| const_iterator lower_bound(const key_type& k) const | Sorted Associative Container | Finds the first element whose key is not less thank. |
| iterator upper_bound(const key_type& k) | Sorted Associative Container | Finds the first element whose key greater than k. |
| const_iterator upper_bound(const key_type& k) const | Sorted Associative Container | Finds the first element whose key greater than k. |
pair<iterator, iterator> equal_range(const key_type& k) |
Sorted Associative Container | Finds a range containing all elements whose key is k. |
pair<const_iterator, const_iterator> equal_range(const key_type& k) const |
Sorted Associative Container | Finds a range containing all elements whose key is k. |
data_type& operator[](const key_type& k) [3] |
map | See below. |
bool operator==(const map&,
const map&)
|
Forward Container | Tests two maps for equality. This is a global function, not a member function. |
bool operator<(const map&,
const map&)
|
Forward Container | Lexicographical comparison. This is a global function, not a member function. |
//下面展示了常用的一些方法。<p>// stu_map.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
#include <map>
using namespace std;
bool fncomp(char lhs,char rhs)
{
return lhs<rhs;
}
struct classcomp
{
bool operator()(const char& lhs,const char& rhs)
{
return lhs<rhs;
}
};
int _tmain(int argc, _TCHAR* argv[])
{
map<char,int> mymap;
mymap['a']=10;
mymap['b']=60;
mymap['c']=30;
mymap['d']=90;
mymap['e']=50;
map<char,int> second(mymap);
map<char,int> third(mymap.begin(),mymap.end());
map<char,int,classcomp> fourth;
bool(*fn_pt)(char,char)=fncomp;
map<char,int,bool(*)(char,char)> fifth(fn_pt);
map<char,int>::key_compare key_comp;
map<char,int>::iterator it;
it=mymap.begin();
for (it;it!=mymap.end();it++)
{
cout<<it->first<<":"<<it->second<<endl;
}
cout<<"================================="<<endl;
second.clear();
second['a']=1002;
second['b']=10023;
while (!second.empty())
{
cout << second.begin()->first << " => ";
cout << second.begin()->second << endl;
second.erase(second.begin());
}
cout<<"================================="<<endl;
mymap.insert(pair<char,int>('f',100) );
mymap.insert(pair<char,int>('g',200) );
cout<<"f => " <<mymap.find('f')->second<<endl;
cout<<"g => " <<mymap.find('g')->second<<endl;
cout<<"================================="<<endl;
key_comp=mymap.key_comp();
cout << "mymap contains:\n";
char highest=mymap.rbegin()->first; // key value of last element
it=mymap.begin();
do {
cout << (*it).first << " => " << (*it).second << endl;
} while ( key_comp((*it++).first, highest) );
cout << endl;
return 0;
}