C++中的各种容器的使用方法汇总

目录

• vector
• 构造函数
• 迭代器iterator
• 访问元素
• 插入与删除元素
• deque
• 构造函数
• 迭代器iterator
• 访问元素
• 插入与删除元素
• insert函数
• queue
• Priority Queues(优先队列)
• stact
• list
• 构造函数
• 迭代器iterator
• 访问元素
• 插入与删除元素
• insert函数
• 合并链表
• set
• 构造函数
• 迭代器iterator
• 插入与删除元素
• unordered_set
• map
• 构造函数
• 迭代器iterator
• 插入与删除元素
• find()与count()
• unordered_map

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
30

map

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
3

unordered_map与unordered_set的存储时按照散列表存储的，输出顺序与输入顺序是不一定相同的

到此这篇关于C++中的各种容器的使用方法的文章就介绍到这了,更多相关C++容器使用内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！