C++中的各种容器的使用方法汇总
目录
vector
vector是封装动态数组的顺序容器。元素相继存储，这意味着不仅可通过迭代器，还能用指向元素的常规指针访问元素。这意味着指向 vector 元素的指针能传递给任何期待指向数组元素的指针的函数。
构造函数
//空的vector容器
vector<int>v1;
//size为5，值的初始化为0的vector容器
vector<int>v2(5);
//size为5，值的初始化为1的vector容器
vector<int>v3(5, 1);
//创建vector时就初始化
vector<int>v4 = { 1,3,4,5,7 };
//利用别的vector创建初始化vector
vector<int>v5(v4);
//指定起始与结束内容创建与初始化
vector<int>v6(v4.begin()+3, v4.end());迭代器iterator
begin() 返回第一个元素的迭代器 end() 返回最末元素的迭代器 rbegin() 返回Vector尾部的逆迭代器 rend() 返回Vector起始的逆迭代器
访问元素
v.at(i) //返回vector v指定位置的元素 v[i] //返回vector v指定位置的元素 v.back() //返回最末一个元素 v.front() //返回第一个元素
插入与删除元素
void push_back( const TYPE &val ); //在Vector最后添加一个元素 void pop_back(); //移除最后一个元素 iterator erase( iterator loc ); //删除指定loc元素 iterator erase( iterator start, iterator end ); //删除[start,end)元素 v.push_back(3); //vector最后添加元素3 v.pop_back(); //删除vector最后一个元素 v.erase(v.begin());//删除位置为begin的元素 v.erase(v.begin(),v.end());//删除区间[begin(),end())的元素
insert函数
//在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器, iterator insert( iterator loc, const TYPE &val ); //在指定位置loc前插入num个值为val的元素 void insert( iterator loc, size_type num, const TYPE &val ); //在指定位置loc前插入区间[start, end)的所有元素 void insert( iterator loc, input_iterator start, input_iterator end ); v.insert(v.begin(),1);//在begin()位置插入元素1 v.insert(v.begin(),5,1);//在begin()位置插入5个值为1的元素 v.insert(v.begin(),v1.begin(),v1.end());//在begin()位置插入区间[v1.begin(),v1.end())的元素
deque
是有下标顺序容器，它允许在其首尾两段快速插入及删除。另外，在 deque 任一端插入或删除不会非法化指向其余元素的指针或引用。
构造函数
//无参，创建一个空双向队列
deque();
//size - 创建一个大小为size的双向队列
deque( size_type size );
//num and val - 放置num个val的拷贝到队列中
deque( size_type num, const TYPE &val );
//from - 从from创建一个内容一样的双向队列
deque( const deque &from );
//start 和 end - 创建一个队列，保存从start到end的元素
deque( input_iterator start, input_iterator end );
deque<int>d1;//空双向队列
deque<int>d2(5);//大小为5，值为0的双向队列
deque<int>d3(5,1);//大小为5，值为1的双向队列
deque<int>d4(d3);//创建一个与d3相同的双向队列
deque<int>d5(d3.begin(),d3.end());
deque<int>d6 = {1,4,6,8};//初始化队列迭代器iterator
begin() 返回第一个元素的迭代器 end() 返回最末元素的迭代器 rbegin() 返回尾部的逆迭代器 rend() 返回起始的逆迭代器
访问元素
d.at(i) //返回指定位置的元素 d[i] //返回指定位置的元素 d.back() //返回最末一个元素 d.front() //返回第一个元素
插入与删除元素
void push_back( const TYPE &val ); //在最后添加一个元素 void pop_back(); //移除最后一个元素 void push_front( const TYPE &val ); //在头部加入一个元素 void pop_front(); //删除头部的元素 iterator erase( iterator loc ); //删除指定loc元素 iterator erase( iterator start, iterator end ); //删除[start,end)元素 iterator emplace( const_iterator pos, Args&&... args ); d.push_back(3); //最后添加元素3 d.pop_back(); //删除最后一个元素 d.push_front(1) //首元素添加元素1 d.pop_front(); //删除首元素 d.erase(d.begin());//删除位置为begin的元素 d.erase(d.begin(),d.end());//删除区间[begin(),end())的元素
insert函数
//在位置为pos插入元素val iterator insert( iterator pos, const TYPE &val ); //在位置为pos插入num个值为val元素 iterator insert( iterator pos, size_type num, const TYPE &val ); //在位置pos插入区间[start,end) void insert( iterator pos, input_iterator start, input_iterator end ); //在begin位置插入元素1 d.insert(d.begin(),1); //在begin位置插入5个值为1的元素 d.insert(d.begin(),5,1); //在begin插入区间[d2.begin(),d2.end()) d.insert(d.begin(),d2.begin(),d2.end());
queue
queue 是STL提供的队列容器
TYPE &back(); //返回最后一个元素 bool empty(); //如果队列空则返回真 TYPE &front() 返回第一个元素 TYPE &pop() 删除第一个元素 void push( const TYPE &val );在末尾加入一个元素
功能就和普通的队列相同
Priority Queues(优先队列)
优先队列类似队列，但是在这个数据结构中的元素按照一定的断言排列有序
priority_queue<Type> priority_queue<Type, Container, Functional> 其中Type 为数据类型， Container 为保存数据的容器，Functional 为元素比较方式。 Container 这里保存的容器一般用vector和deque priority_queue<int> q; //排序顺序默认为降序，也就是创建了大顶堆 priority_queue<int,vector<int>,less<int>> q; //排序顺序为升序，创建了小顶堆
优先级队列，这个容器可以用set来实现。
stact
该容器与现实数据结构stack相同
bool empty() //堆栈为空则返回真 void pop(); //移除栈顶元素 void push( const TYPE &val ); //在栈顶增加元素 size_type size(); //返回栈中元素数目 TYPE &top(); //返回栈顶元素
list
List将元素按顺序储存在链表中. 与 vector相比, 它允许快速的插入和删除，但是随机访问却比较慢
构造函数
list<T> lst; //list采用模板类实现对象的默认构造形式：
list(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem); //构造函数将n个elem拷贝给本身。
list(const list &lst); //拷贝构造函数。
list<int>L; //空的list容器
list<int>L2(5);//大小为5值为0的容器
list<int>L3(5,1);//大小为5值为1的容器
list<int>L4(L3);//用L3创建容器
list<int>L5 = {1,4,6,8,4};//初始化容器迭代器iterator
iterator begin(); //返回指向第一个元素的迭代器 iterator end() //返回末尾的迭代器 iterator rbegin() //返回指向第一个元素的逆向迭代器 iterator rend() //返回list末尾的逆向迭代器
访问元素
L.back() //返回最末一个元素 L.front() //返回第一个元素
插入与删除元素
void push_back( const TYPE &val ); //在最后添加一个元素
void pop_back(); //移除最后一个元素
void push_front( const TYPE &val ); //在头部加入一个元素
void pop_front(); //删除头部的元素
iterator erase( iterator loc ); //删除指定loc元素
iterator erase( iterator start, iterator end ); //删除[start,end)元素
void remove( const TYPE &val ); //删除所有的指定元素
void remove_if( UnPred pr );//以一元谓词pr为判断元素的依据，遍历整个链表。如果pr返回true则删除该元素
L.push_back(3); //最后添加元素3
L.pop_back(); //删除最后一个元素
L.push_front(1) //首元素添加元素1
L.pop_front(); //删除首元素
L.erase(d.begin());//删除位置为begin的元素
L.erase(d.begin(),d.end());//删除区间[begin(),end())的元素
L.remove(1); //删除元素1
L.remove_if([](int n) { return n > 4; }); //删除大于4的元素insert函数
//在位置为pos插入元素val iterator insert( iterator pos, const TYPE &val ); //在位置为pos插入num个值为val元素 iterator insert( iterator pos, size_type num, const TYPE &val ); //在位置pos插入区间[start,end) void insert( iterator pos, input_iterator start, input_iterator end ); //在begin位置插入元素1 L.insert(L.begin(),1); //在begin位置插入5个值为1的元素 L.insert(L.begin(),5,1); //在begin插入区间[L2.begin(),L2.end()) L.insert(L.begin(),L2.begin(),L2.end());
合并链表
merge()合并两个list，要求两个list必须有序；
splice()不需要list有序，splice()不复制或移动元素，仅重指向链表结点的内部指针
可以用advance调整iterator 的位置
void merge( list &lst ); //合并两个list必须有序，默认是升序，被合并list会被清空 void merge( list &lst, Comp compfunction ); //合并两个list，按照指定的顺序排序 void splice( iterator pos, list &lst ); //将lst指向pos位置 void splice( iterator pos, list &lst, iterator del ); //将lst中del指向pos void splice( iterator pos, list &lst, iterator start, iterator end );//将lst区间start与end元素指向pos L.merge(L2); //将L2合并到L L.merge(L2,Compare); //将L2合并到L，指定Compare规则 L.splie(L.begin(),L2); //将L2整个list指向L.begin()位置 L.splie(L.begin(),L2,L2.begin()); //从L2的迭代器L2.begin()开始指向L.begin()位置 L.splie(L.begin(),L2,L2.begin(),L2.end()); //将L2的迭代器区间[L2.begin(),L2.end())指向L的迭代器L.begin()位置
set
set容器的底层是由二叉树构成。set在插入元素时，是不允许插入重复元素的；multiset是允许插入重复元素的。set会自动排序，默认是升序。
构造函数
set中不存在set s(size_type num,T val)。因为set不允许重复元素。
iterator begin(); //返回指向第一个元素的迭代器 iterator end() //返回末尾的迭代器 iterator rbegin() //返回指向第一个元素的逆向迭代器 iterator rend() //返回末尾的逆向迭代器 iterator lower_bound() //返回指向大于（或等于）某值的第一个元素的迭代器 iterator upper_bound() //返回大于某个值元素的迭代器
可以使用set<T,Compare>指定排序规则。
迭代器iterator
iterator begin(); //返回指向第一个元素的迭代器 iterator end() //返回末尾的迭代器 iterator rbegin() //返回指向第一个元素的逆向迭代器 iterator rend() //返回末尾的逆向迭代器 iterator lower_bound() //返回指向大于（或等于）某值的第一个元素的迭代器 iterator upper_bound() //返回大于某个值元素的迭代器
插入与删除元素
iterator begin(); //返回指向第一个元素的迭代器 iterator end() //返回末尾的迭代器 iterator rbegin() //返回指向第一个元素的逆向迭代器 iterator rend() //返回末尾的逆向迭代器 iterator lower_bound() //返回指向大于（或等于）某值的第一个元素的迭代器 iterator upper_bound() //返回大于某个值元素的迭代器
unordered_set
unordered_set 容器，为“无序 set 容器”。即 unordered_set 容器和 set 容器很像，唯一的区别就在于 set 容器会自行对存储的数据进行排序，而 unordered_set 容器不会
unordered_set<int>s;
s.insert(10);
s.insert(60);
s.insert(30);
s.insert(90);
for (auto a : s) {
cout << a<< endl;
}
--------------------------
90
10
60
30map
map 是有序键值对容器，默认是升序，它的元素的键是唯一的。用比较函数 Compare 排序键。 map 通常实现为红黑树。mutlimap是允许存储重复元素。
构造函数
set中不存在map s(size_type num,T val)。因为set不允许重复元素。
map<T>m; //采用模板类实现对象的默认构造形式： map<T>m(const map& ml); //拷贝函数，将s初始化为se一样 map<T>m(iterator start,iterator end) //将s的初始化为[start,end)区间 map<int>m1; map<int>m2(m); map<int>m3(m.begin(),m.end());
可以使用map<T1,T2,Compare>指定排序规则。
迭代器iterator
iterator begin(); //返回指向第一个元素的迭代器 iterator end() //返回末尾的迭代器 iterator rbegin() //返回指向第一个元素的逆向迭代器 iterator rend() //返回末尾的逆向迭代器 iterator lower_bound() //返回指向大于（或等于）某值的第一个元素的迭代器 iterator upper_bound() //返回大于某个值元素的迭代器
插入与删除元素
iterator insert(const pair &p)； //在集合中插入元素 void insert( input_iterator start, input_iterator end );//插入区间[start,end)元素 void erase( iterator i ); //删除i的元素 void erase( iterator start, iterator end ); //删除区间[start,end)中的元素 size_type erase( const key_type &key ); //删除指定元素值 m.insert(make_pair(1,10)); //插入pair(1,10) m.insert(s2.begin(),s2,end()); //插入区间[begin,end)元素 m.erase(m.begin()); //删除元素为begin()中的元素 m.erase(m.begin(),m.end()); //删除区间[begin,end)的元素 m.erase(1); //删除key为1的pair
find()与count()
//返回一个迭代器指向键值为key的元素，如果没找到就返回指向map尾部的迭代器 iterator find( const KEY_TYPE &key ); //还回map中键值等于key的元素的个数。map只会返回0、1，mutlimap会返回值的个数 size_type count( const KEY_TYPE &key ); map<int ,int>::iterator it=m.find(10) //在m中查找key为10的元素 int num=m.count(10); //查找key为10的值
unordered_map
unordered_map与map的用法基本一直，最大的区别在于：
map的key是有序的，而unordered_map的key为无序。
#include<unordered_map>
int main() {
unordered_map<int, int>m;
m.insert(make_pair(1, 10));
m.insert(make_pair(1, 20));//key相同是不会重复存储的
m.insert(make_pair(6, 20));
m.insert(make_pair(3, 30));
m.insert(make_pair(9, 50));
for (auto a : m) {
cout << a.first << endl;
}
return 0;
}
-----------------------------
9
1
6
3unordered_map与unordered_set的存储时按照散列表存储的，输出顺序与输入顺序是不一定相同的
原文地址：https://blog.csdn.net/weixin_45939085/article/details/128608489