所在头文件:
std::map 类模板:
template < class Key, // map::key_type
class T, // map::mapped_type
class Compare = less, // map::key_compare
class Alloc = allocator > // map::allocator_type
> class map;
typedef pair<const Key, T> value_type;
类型成员 | 定义 |
---|---|
key_type | 第一个模板参数(Key) |
mapped_type | 第二个模板参数(T) |
value_type | pair |
key_compare | 第三个模板参数(Compare) |
关联性:std::map 是一个关联容器,其中的元素根据键来引用,而不是根据索引来引用。
有序性:在内部,std::map 中的元素总是按照其内部的比较器(比较器类型由Compare类型参数指定)指示的特定严格弱序标准按其键排序。
唯一性:std::map 中的元素的键是唯一的。
std::map 通常由二叉搜索树实现。
构造方式 | 函数声明 |
---|---|
构造空map | explicit map (const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type()); explicit map (const allocator_type& alloc); |
由一对范围迭代器指定输入 | template map (InputIterator first, InputIterator last, const key_compare& comp = key_compare(), const allocator_type& = allocator_type()); |
复制构造 | map (const map& x); map (const map& x, const allocator_type& alloc); |
移动构造 | map (map&& x); map (map&& x, const allocator_type& alloc); |
利用初始化列表构造 | map (initializer_list const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type()); |
例子:
// constructing maps
#include
#include
// 比较器1
bool fncomp (char lhs, char rhs) {
return lhs < rhs;
}
// 比较器2
struct classcomp {
bool operator() (const char& lhs, const char& rhs) const {
return lhs<rhs;
}
};
int main () {
// 默认构造,构造一个空的map
std::map<char,int> first;
first['a']=10;
first['b']=30;
first['c']=50;
first['d']=70;
// 由一对范围迭代器指定输入
std::map<char,int> second (first.begin(), first.end());
// 复制构造
std::map<char,int> third (second);
// 指定比较器:使用类
std::map<char, int, classcomp> fourth; // class as Compare
// 指定比较器:使用函数指针
bool(*fn_pt)(char, char) = fncomp;
std::map<char, int, bool(*)(char,char)> fifth (fn_pt); // function pointer as Compare
return 0;
}
赋值方式 | 函数声明 |
---|---|
复制 | map& operator= (const map& x); |
移动 | map& operator= (map&& x); |
初始化列表 | map& operator= (initializer_list |
函数声明 | 解释 | 返回值类型 |
---|---|---|
begin() | 返回一个迭代器,指向第一个元素 | iterator 或 const_iterator |
end() | 返回一个迭代器,指向尾后元素 | iterator 或 const_iterator |
rbegin() | 返回一个反向迭代器,指向最后一个元素 | reverse_iterator 或 const_reverse_iterator |
rend() | 返回一个反向迭代器,指向第一个元素之前虚拟的元素 | reverse_iterator 或 const_reverse_iterator |
cbegin() | 返回一个常量迭代器,指向第一个元素 | const_iterator |
cend() | 返回一个常量迭代器,指向尾后元素 | const_iterator |
crbegin() | 返回一个常量反向迭代器,指向最后一个元素 | const_reverse_iterator |
crend() | 返回一个常量反向迭代器,指向第一个元素之前虚拟的元素 | const_reverse_iterator |
函数声明 | 解释 |
---|---|
bool empty() const noexcept; | map 是否为空 |
size_type size() const noexcept; | 获取map 中元素的数量 |
访问方式 | 函数声明 | 解释 |
---|---|---|
使用方括号([]) | mapped_type& operator[] (const key_type& k); mapped_type& operator[] (key_type&& k); |
如果 k 匹配容器中某个元素的键,则该函数返回该映射值的引用。 如果 k 与容器中任何元素的键都不匹配,则该函数将使用该键插入一个新元素,并返回该映射值的引用。 |
使用 at() | mapped_type& at (const key_type& k); const mapped_type& at (const key_type& k) const; |
如果 k 匹配容器中某个元素的键,则该函数返回该映射值的引用。 如果 k 与容器中任何元素的键都不匹配,则该函数将抛出 out_of_range 异常。 |
注意:const std::map 不能使用 operator[] 操作!!
插入方式 | 函数声明 | 说明 |
---|---|---|
插入单个元素 | pair template pair |
返回一个pair,其中第一个值为一个迭代器,指向新插入的元素或其键等于待插入元素的键的元素(原先就已存在的元素);第二个值是一个bool值,当插入一个新元素时,该值设为true,当该键已存在时,该值设为false |
带插入位置提示 | iterator insert (const_iterator position, const value_type& val); template iterator insert (const_iterator position, P&& val); |
返回一个迭代器,该迭代器指向新插入的元素或指向键相等的已存在元素。 |
由一对范围迭代器指定输入 | template void insert (InputIterator first, InputIterator last); |
|
使用初始化列表指定插入元素 | void insert (initializer_list |
例子:
// map::insert (C++98)
#include
#include
int main () {
std::map<char, int> mymap;
// 插入单个元素
mymap.insert ( std::pair<char,int>('a',100) );
mymap.insert ( std::pair<char,int>('z',200) );
std::pair<std::map<char,int>::iterator,bool> ret;
ret = mymap.insert ( std::pair<char,int>('z',500) );
if (ret.second==false) {
std::cout << "element 'z' already existed";
std::cout << " with a value of " << ret.first->second << '\n';
}
// 带插入位置提示,只是提示,并不强制插入此位置
std::map<char,int>::iterator it = mymap.begin();
mymap.insert (it, std::pair<char,int>('b',300)); // max efficiency inserting
mymap.insert (it, std::pair<char,int>('c',400)); // no max efficiency inserting
// 由一对范围迭代器指定输入
std::map<char,int> anothermap;
anothermap.insert(mymap.begin(), mymap.find('c'));
// 打印内容
std::cout << "mymap contains:\n";
for (it=mymap.begin(); it!=mymap.end(); ++it)
std::cout << it->first << " => " << it->second << '\n';
std::cout << "anothermap contains:\n";
for (it=anothermap.begin(); it!=anothermap.end(); ++it)
std::cout << it->first << " => " << it->second << '\n';
return 0;
}
删除方式 | 函数声明 | 说明 |
---|---|---|
根据元素位置 | iterator erase (const_iterator position); | 返回一个迭代器,指向被删除元素的后一个元素 |
根据元素的键 | size_type erase (const key_type& k); | 返回被删除元素的数目,此处为1 |
由一对范围迭代器指定删除的范围 | iterator erase (const_iterator first, const_iterator last); | 返回一个迭代器,指向最后一个被删除元素的后一个元素 |
删除所有元素 | void clear() noexcept; |
例子:
// erasing from map
#include
#include
int main () {
std::map<char,int> mymap;
std::map<char,int>::iterator it;
// insert some values:
mymap['a']=10;
mymap['b']=20;
mymap['c']=30;
mymap['d']=40;
mymap['e']=50;
mymap['f']=60;
it=mymap.find('b');
mymap.erase (it); // 删除迭代器指向的元素
mymap.erase ('c'); // 删除相应键值的元素
it=mymap.find ('e');
mymap.erase ( it, mymap.end() ); // 删除一个范围内的所有元素
// show content:
for (it=mymap.begin(); it!=mymap.end(); ++it)
std::cout << it->first << " => " << it->second << '\n';
return 0;
}
函数声明 | 说明 |
---|---|
iterator find (const key_type& k); const_iterator find (const key_type& k) const; |
在容器中搜索键值等于 k 的元素,如果找到,则返回一个指向该元素的迭代器,否则返回一个指向map :: end的迭代器。 |
例子:
// map::find
#include
#include
int main () {
std::map<char,int> mymap;
std::map<char,int>::iterator it;
mymap['a']=50;
mymap['b']=100;
mymap['c']=150;
mymap['d']=200;
// 查找
it = mymap.find('b');
if (it != mymap.end())
mymap.erase (it);
// print content:
std::cout << "elements in mymap:" << '\n';
std::cout << "a => " << mymap.find('a')->second << '\n';
std::cout << "c => " << mymap.find('c')->second << '\n';
std::cout << "d => " << mymap.find('d')->second << '\n';
return 0;
}
函数声明 | 说明 |
---|---|
iterator lower_bound (const key_type& k); const_iterator lower_bound (const key_type& k) const; |
返回一个迭代器,指向容器中第一个键值等于 k 或排在 k 之后的元素 |
iterator upper_bound (const key_type& k); const_iterator upper_bound (const key_type& k) const; |
返回一个迭代器,指向容器中第一个键值排在 k 之后的元素 |
pair pair |
返回一对迭代器,该范围内的所有元素的键值等于 k,当然,此处只包含一个元素。 如果找不到键值与 k 相等的元素,则两个迭代器均指向排在 k 之后的第一个元素。 |
例子:
// map::lower_bound/upper_bound
#include
#include
int main () {
std::map<char,int> mymap;
std::map<char,int>::iterator itlow,itup;
mymap['a']=20;
mymap['b']=40;
mymap['c']=60;
mymap['d']=80;
mymap['e']=100;
itlow=mymap.lower_bound ('b'); // itlow points to b:等于或大于'b'
itup=mymap.upper_bound ('d'); // itup points to e (not d!):大于'd'
mymap.erase(itlow,itup); // erases [itlow,itup)
// print content:
for (std::map<char,int>::iterator it=mymap.begin(); it!=mymap.end(); ++it)
std::cout << it->first << " => " << it->second << '\n';
return 0;
}
参考:http://www.cplusplus.com/reference/map/map/