std::map关联容器底层二叉树结构，查询时间复杂度O(logn)；
#include
map类模板声明
template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
class map
{
public:
typedef _Key key_type;
typedef _Tp mapped_type;
typedef std::pair<const _Key, _Tp> value_type;
typedef _Compare key_compare;
typedef _Alloc allocator_type;
…
};
_Key 是key值
_Tp 保存值类型
_Compare 小于函数，因为map天然有序性所以必须实现小于比较函数，基本类型不用,如果是自己定义的类型需要实现此函数
std::pair<const _Key, _Tp> Key 和 T 一起组成了 std::map 的 value_type：
构造函数
-
map() 默认构造
例：map<int,int> m; -
map(const _Compare& __comp, const allocator_type& __a = allocator_type()) 构造空map
例：
typedef bool(*Compare)(int, int); //定义比较函数别名
bool fncomp (int a, int b) {
return a< b;
} //自定义实现比较函数
Compare fun = fncomp; //创建比较函数
map<int,data,Compare> m(fun); //传入的比较函数fun要与第三个模板参数Compare类型匹配 -
map(const map& __x) 复制构造
例：
map<int,int> m1;
map<int,int> m2(m1); -
map(map&& __x) 移动构造
例：
map<int,int> m;
m[1] = 1;
m[2] = 2;
map<int,int> m2(std::move(m)); //移动构造后m变为空，里面数据被转移到m2 -
map(initializer_list<value_type> __l,
const _Compare& __comp = _Compare(),
const allocator_type& __a = allocator_type()) 利用初始化列表构造
例：
map<int,int> m1({std::pair<int,int>(2,400),std::pair<int,int>(3,400),std::pair<int,int>(4,400)});
要理解:value_type就是std::pair<const _Key, _Tp>; -
map(_InputIterator __first, _InputIterator __last) 迭代器指定输入
例：
map<int,int> m1;
map<int,int> m2(m1.begin(), m1.end()); -
map(_InputIterator __first, _InputIterator __last,
const _Compare& __comp,
const allocator_type& __a = allocator_type()) 迭代器指定输入
例：
typedef bool(*Compare)(int, int); //定义比较函数别名
bool fncomp (int a, int b) {
return a< b;
} //自定义实现比较函数
Compare fun = fncomp; //创建比较函数
map<int,int> m1;
map<int,int,Compare> m2(m1.begin(), m1.end(),fun);//fun要与第三个模板参数Compare类型匹配
自定义结构体作为key
1.结构体实现 bool operator<(const data & key)const 函数
struct data
{
int a;
int b;
bool operator < (const data &A) const
{
return this->a<A.a;
}
data():a(10),b(20){}
data(int a,int b):a(a),b(b){}
};
map<data,int> m;
2.定义一个比较操作函数传入参数
typedef bool(*Compare)(const data &a , const data &b ); //定义比较函数别名
bool fncomp (const data &a, const data &b) {
return a.a < b.a;
} //自定义实现比较函数
map<data ,int,Compare> m(fncomp); //传入的比较函数fun要与第三个模板参数Compare类型匹配
3.定义一个比较操作对象
struct datacomp{
bool operator() (data const &A, data const &B) const
{return A.b<B.b;}
};
map<data,int,datacomp> m;
赋值
-
map& operator=(const map& __x) 普通赋值
例：
map<int,int> m1;
m[1] = 1;
m[2] = 2;
map<int,int> m2 = m; -
map& operator=(map&& __x) 移动赋值
例：
map<int,int> m1;
m[1] = 1;
m[2] = 2;
map<int,int> m2 = std::move(m); //移动赋值后m为空，数据被移动到m2里面 -
map& operator=(initializer_list<value_type> __l)初始化列表赋值
例：
map<int,int> m1;
m1 = {std::pair<int,int>(2,400),std::pair<int,int>(3,400),std::pair<int,int>(4,400)};
增加
-
mapped_type& operator[] (const key_type& k); 访问即插入
例：
使用[]去访问不存在的key，则该函数将使用该键插入一个新元素，并返回该映射值的引用。
map<int,int> m;
m[1]; //key=1不存在所以会插入一个std::pair<int,int>(1,0)，如果_Tp是结构体会插入其默认构造函数创建的对象std::pair<int,data>(1,data()) -
std::pair<iterator, bool> emplace(_Args&&… __args)
直接构造新元素，从而避免复制和移动操作，如果key已经存在插入失败,原来的值不变,根据返回std::pair<iterator, bool>中bool判断是否插入成功。
例：
map<int,int> m;
pair<map<int, int>::iterator, bool> pair = m.emplace(std::pair<int,int>(5,500));
if(pair.second)
{
cout<<“插入成功”；
}else
{
cout<<“插入失败”；
} -
iterator emplace_hint(const_iterator __pos, _Args&&… __args)
__pos参数只是作为应该插入对的位置的提示的迭代器，可以潜在地改进插入过程的性能,不影响实际插入位置，插入后map还是有序的。
如果新元素被插入，它返回的是指向新元素的迭代器；
如果没有插入，返回这个键匹配的现有元素的迭代器；
判断插入成功的唯一方法是用 size() 成员函数来获取插入前后的map中元素的数量，如果数量增加则插入成功
例：
map<int,int> m1;
m1[1];
m1[2];
int size1 = m1.size();
m1.emplace_hint(m1.begin(),std::pair<int,int>(3,3));
int size2 = m1.size();
if(size2>size1)
{
cout<<“插入成功”;
}else
{
cout<<“插入失败”;
} -
std::pair<iterator, bool> insert(const value_type& __x)
如果key已经存在插入失败,原来的值不变,根据返回std::pair<iterator, bool>中bool判断是否插入成功。
例:
map<int,int> m;
m.insert(std::pair<int,int>(4,400)); -
std::pair<iterator, bool> insert(_Pair&& __x)
例:
map<int,int> m;
m.insert(map<int,int>::value_type(2,200)); -
void insert(std::initializer_list<value_type> __list)
例:
map<int,int> m;
m[2] = 100;
m.insert({std::pair<int,int>(4,40),std::pair<int,int>(3,30),std::pair<int,int>(2,20)}); //std::pair<int,int>(2,20)不会被插入
**注意:**如果插入的value_type的key已经存在则不会插入如std::pair<int,int>(2,20)，其他的正常插入 -
iterator insert(const_iterator __position, const value_type& __x)
例:
map<int,int> m1;
map<int,int> m2;
m2.insert(m2.begin(),std::pair<int,int>(2,20));
__position参数只是作为应该插入对的位置的提示的迭代器，可以潜在地改进插入过程的性能,不影响实际插入位置，插入后map还是有序的。 -
iterator insert(const_iterator __position, _Pair&& __x)
例:
map<int,int> m1;
map<int,int> m2;
m2.insert(m2.begin(),map<int,int>::value_type(2,200)); -
void insert(_InputIterator __first, _InputIterator __last)
例:
map<int,int> m1;
map<int,int> m2;
m2.insert(m1.begin(),m1.begin()+3); //只插入m1的前三个
m2.insert(m1.begin(),m1.end());
删除
-
iterator erase(const_iterator __position)
返回一个迭代器，指向被删除元素的后一个元素；__position不能超出[begin~end)范围不能等于end，否则出现未知错误
map<int,int> m1;
m1.erase(m1.end()); //错误使用方法不能大于等于end()
m1.erase(m1.begin()-1); //错误使用方法小于begin()
m1.erase(m1.begin()+1); -
iterator erase(iterator __position)
同上1 -
size_type erase(const key_type& __x)
删除一个元素，返回删除个数key存在返回1、不存在返回0
map<int,int> m1;
m[1] =1;
m1.erase(1); //存在key=1，返回1
m1.erase(0); //不存在key=0，返回0 -
iterator erase(const_iterator __first, const_iterator __last)
返回指向最后一个被删除元素的后一个元素,first>end,否则可能不会出现异常但是运行非预期，非常危险特别是first==end的时候
map<int,int> m1;
m1[0] = 0; m1[1] = 1; m1[2] = 2; m1[3] = 3; m1[4] = 4;
m1.erase(m1.begin(),m1.begin()+3);//删除前三个元素
查看
-
mapped_type& operator[](const key_type& __k)
-
mapped_type& operator[](key_type&& __k)
获取key对应的数据结构,如果key不存在，则该函数将使用该键插入一个新元然后返回 -
mapped_type& at(const key_type& __k)
-
const mapped_type& at(const key_type& __k)
获取key对应的数据结构，如果key不存在抛出std::out_of_range异常
map<int,int> m1;
m1[0] = 10; m1[1] = 11; m1[2] = 12;
m1.at(5); //抛出异常
m1.at(2); //12 -
iterator find(const key_type& __x)
-
const_iterator find(const key_type& __x) const
查找一个元素返回一个指向该元素的迭代器，不存在返回一个指向map :: end的迭代器
map<int,int> m1;
m1[0] = 10; m1[1] = 11; m1[2] = 12;
map<int,int>::iterator it = m1.find(1); //返回指向key等于1的迭代器 it->first=1, it->second=11
map<int,int>::iterator it = m1.find(3); //返回m1.end() -
iterator lower_bound(const key_type& __x)
-
const_iterator lower_bound(const key_type& __x) const
返回键值大于等于给定元素的第一个迭代器
map<int,int> m1;
m1[0] = 10; m1[3] = 13; m1[5] = 15; m1[7] = 17;
m1.lower_bound(3); //返回key=3的迭代器
m1.lower_bound(4); //返回key=5的迭代器,第一个大于等于4的迭代器
m1.lower_bound(9); //返回等于m1.end()的迭代器 -
iterator upper_bound(const key_type& __x)
-
const_iterator upper_bound(const key_type& __x) const
返回键值大于给定元素的第一个位置
map<int,int> m1;
m1[0] = 10; m1[3] = 13; m1[5] = 15; m1[7] = 17;
m1.upper_bound(3); //返回key=5的迭代器
m1.upper_bound(4); //返回key=5的迭代器,第一个大于4的迭代器
m1.upper_bound(9); //返回等于m1.end()的迭代器
修改
-
void swap(map& __x) //交换两个map
map<int,int> m1;
map<int,int> m2;
m1.swap(m2); -
void clear() //删除所有元素
map<int,int> m2;
m2.clear(); //清空后为空
空间和大小
- bool empty() const //如果map为空则返回true
- size_type size() //返回map中元素的个数
- size_type max_size() //最大添加元素数量
迭代器
-
正向迭代器
iterator begin()
iterator end()
例:
map<int,int> m1;
m1[0] = 10; m1[1] = 11; m1[2] = 12;
map<int,int>::iterator it;
for(it=m1.begin();it!=m1.end();it++) //输出10 11 12
{
cout << it->second<<endl;
it->second = 1; //value可以修改
//it->first = 1;//key不能修改
} -
正向常量迭代器
const_iterator begin() const
const_iterator end() const
const_iterator cbegin() const
const_iterator cend() const
例:
map<int,int> m1;
m1[0] = 10; m1[1] = 11; m1[2] = 12;
map<int,int>::const_iterator it;
for(it=m1.cbegin();it!=m1.cend();it++) //for(it=m1.begin();it!=m1.end();it++)
{
cout << it->second<<endl;
// it->second = 1; //常量迭代器不能修改
} -
反向迭代器
reverse_iterator rbegin()
reverse_iterator rend()
例:
map<int,int> m1;
m1[0] = 10; m1[1] = 11; m1[2] = 12;
map<int,int>::reverse_iterator it;
for(it=m.rbegin();it!=m.rend();it++)//输出12 11 10
{
cout << it ->first <<":"<< it->second;
it->second = 1;
} -
反向常量迭代器
const_reverse_iterator rbegin() const
const_reverse_iterator rend() const
const_reverse_iterator crbegin()
const_reverse_iterator crend()
例:
map<int,int> m1;
m1[0] = 10; m1[1] = 11; m1[2] = 12;
map<int,int>::const_reverse_iterator it;
for(it=m1.crbegin();it!=m1.crend();it++) // for(it=m.rbegin();it!=m.rend();it++)
{
cout << it->second<<endl;
// it->second = 1; //常量迭代器不能修改
}
其他
-
key_compare key_comp() const
返回比较key元素的函数
typedef bool(*Compare)(int, int); //定义比较函数别名
bool fncomp (int a, int b) {
return a< b;
} //自定义实现比较函数
Compare fun = fncomp; //创建比较函数
map<int,int,Compare> m(fun); //传入的比较函数fun要与第三个模板参数Compare类型匹配
Compare fun2 = m.key_comp(); //返回的就是第三个模板参数Compare函数
cout<<fun2(1,2)<<endl; -
value_compare value_comp()
返回比较元素value_type的函数,实际相当于m.key_comp()进行key比较
typedef bool(*compfun)(int, int);
bool fncomp (int lhs, int rhs) {
return lhs < rhs;
}
compfun fun = fncomp; //创建比较函数
map<int,int,compfun> m(fun); //传入的比较函数fun要与第三个模板参数Compare类型匹配
m[1]=111;
m[2]=111;
m[3]=111;
m[4]=111;
map<int,int,compfun>::value_compare fun2 = m.value_comp();
cout<< fun2(pair<int,int>(3,10),pair<int,int>(4,10))<<endl;//3<4 true
cout<< fun2(pair<int,int>(4,10),pair<int,int>(4,10))<<endl;//4<3 false -
size_type count(const key_type& __x) const
一般只在multimaps中使用；返回指定key出现的次数,也可以判断key是否已经存在
map<int,int> m;
m[1] = 1;
m.count(1); //返回1
m.count(0); //返回0 -
std::pair<iterator, iterator> equal_range(const key_type& __x)
-
std::pair<const_iterator, const_iterator> equal_range(const key_type& __x) const
一般只在multimaps中使用；返回包含一对迭代器,
其key迭代器是大于等于k的第一个迭代器
其value迭代器是大于k的第一个迭代器迭代器
相当于 std::make_pair(m.lower_bound(key), m.upper_bound(key));
map<int,int> m;
m[1] = 11;
m[3] = 33;
m[5] = 66;
map<int,int>::iterator begin = m.begin();
map<int,int>::iterator end = m.end();
std::pair<map<int,int>::iterator, map<int,int>::iterator> it = m.equal_range(0);
//it->first == begin; it->second == begin;std::pair<map<int,int>::iterator, map<int,int>::iterator> it1 = m.equal_range(1);
//it1->first == begin; it1->second == begin+1;std::pair<map<int,int>::iterator, map<int,int>::iterator> it2 = m.equal_range(2);
//it2->first == begin+1; it2->second == begin+1;std::pair<map<int,int>::iterator, map<int,int>::iterator> it3 = m.equal_range(3);
//it3->first == begin+1; it3->second == begin+2;std::pair<map<int,int>::iterator, map<int,int>::iterator> it4 = m.equal_range(5);
//it4->first == begin+2; it4->second == end;std::pair<map<int,int>::iterator, map<int,int>::iterator> it5 = m.equal_range(6);
//it5->first == end; it5->second == end;
扫一扫
691
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
