c++学习--详细带你了解不同容器之间的常用方法总结与不同之处。

学习视频：黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难
因为可能会因为不同容器而有不同的头文件，为了方便我们直接使用万能头文件：

#include 

常用容器总结与对比：
因为有些代码过长，表格无法完全表示，我用名字来代替，可以在下面找到相应的代码。例如：vector_1，可以在下方找到vector的构造函数。

容器名称	vector	deque	stack	queue
底层数据结构	单端数组	双端数组	栈	队列
构造函数	vector_1	deque_1	stack_1	queue_1
是否允许遍历	是	是	否	否
赋值操作	vector_2	deque_2	stack_2	queue_2
存储操作	push_back(ele); //插入ele数据 pop_back(); //删除最后一个数据	push_back(elem); //在尾部添加一个数据 push_front(elem); //在头部插入一个数据 pop_back(); //删除容器最后一个数据 pop_front(); //删除容器第一个数据	push(elem); //栈顶添加元素 pop(); //从栈顶移除第一个元素 top(); //返回栈顶元素	push(elem); //往队尾添加元素 pop(); //从队头移除第一个元素 back(); //返回最后一个元素 front(); //返回第一个元素
大小操作	vector_3 因为vector容量可动态扩展， 所以还有个容量知识点	deque_3	stack_3	queue_3
插入和删除	vector_4	deque_4	无	无
元素的获取	[]或者at方法	[]或者at方法	无	无
容器内部其他算法	vector< int>v1; vector< int> v2; //容器交换 v1.swap(v2);	deque< int> d1; deque< int> d2; //容器交换 d1.swap(d2);	stack s1; stack s2; //容器交换 s1.swap(s2);	deque d1; deque d2; //容器交换 d1.swap(d2);
c++的标准算法:sort,for_each,find等是否可以使用	可以	可以	可以	可以

容器名称	list	set	map
底层数据结构	链表	二叉树 自动排序而且去除重复元素	二叉树 所有元素都是pair型(键值对) 不允许用重复的key元素
构造函数	list_1	set_1	map_1
是否允许遍历	是	是	是
赋值操作	list_2	set_2	map_2
存储操作	push_back(ele); //插入ele数据 pop_back(); //删除最后一个数据	insert(ele); 插入ele数据	insert(pair(1, 10)); 插入键值对1:10
大小操作	list_3	set_3	map_3
插入和删除	list_4	insert(ele); 插入ele元素 erase(ele); 删除ele元素	map_4
元素的获取	通过遍历获取	通过遍历获取	通过遍历获取
容器内部其他算法	list_5	set_4	map_5
c++的标准算法:sort,for_each,find等是否可以使用	不能	不能	不能

1.vector容器

vector_1：vector构造函数：

vector v1; //无参构造;
vector v2(v1.begin(), v1.end());//区间拷贝构造函数;
vector v3(v2);//拷贝构造函数

vector_2:赋值操作

//直接赋值操作
vector v1; //无参构造
vectorv2;
v2 = v1;

//区间拷贝赋值，这种方法使用比较少。
vectorv3;
v3.assign(v1.begin(), v1.end());

vector_3:vector的大小与容量操作

vector v1;
//判断容器是否为空
v1.empty();
//容器的容量
v1.capacity();
//容器元素个数
v1.size();
//重新指定容器大小
v1.resize(2);

vector_4:vector的删除与插入操作

//迭代器指向位置v1.begin()前插入元素100
vector v1;
v1.insert(v1.begin(), 100);

//迭代器指向位置v1.begin()前插入2个元素1000
v1.insert(v1.begin(), 2, 1000);

//删除v1.begin()处的数据
v1.erase(v1.begin());

//删除v1.begin()到v1.begin()+1的元素
 v1.erase(v1.begin(),v1.begin()+2);

//清空
v1.clear();

2.deque容器

deque_1:deque的构造函数

deque d1; //无参构造函数
deque d2(d1.begin(), d1.end());//区间拷贝构造函数;
deque d3(d2);//拷贝构造函数

deque_2:赋值操作

//直接赋值操作
deque d1; //无参构造
dequed2;
d2 = d1;

//区间拷贝赋值，这种方法使用比较少。
dequed3;
d3.assign(d1.begin(), d1.end());

deque_3:大小操作

deque d1;
//判断容器是否为空
d1.empty();
//容器元素个数
d1.size();
//重新指定容器大小
d1.resize(2);

deque_4:deque的删除与插入操作

//在d1.begin()前位置插入一个1000
deque d1
d1.insert(d1.begin(),1000); 

//在d1.begin()位置插入2个100数据，无返回值。
d1.insert(d1.begin(),2,100); 

//清空
d1.clear(); 

//删除[begin,end)区间的数据。
d1.erase(d1.begin(),d1.end()); 

/删除d1.begin()位置的数据，返回下一个数据的位置。
d1.erase(d1.begin()); 

3.stack容器

stack_1:stack的构造函数

因为stack栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为，begin和end方法都不能使用，所有没有区间拷贝构造函数。

stack s1; //无参构造函数
stack s2(s1); //拷贝构造函数

stack_2:赋值操作

//直接赋值操作，无拷贝赋值操作
stack s1;
stack s2;
s2=s1;

stack_3:大小操作

//判断s1是否为空
stack s1;
s1.empty();

//判断s1的元素个数
s1.size();

4.queue容器

queue_1:queue的构造函数

因为queue队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为，begin和end方法都不能使用，所有没有区间拷贝构造函数。

queue q1; //无参构造函数
queue q2(q1); //拷贝构造函数

queue_2:赋值操作

//直接赋值操作
queue q1; //无参构造
queue q2;
q2 = q1;

queue_3:大小操作

//判断是否为空
queue q1;
q1.empty();

//判断元素个数
q1.size();

5.list容器

list_1:list的构造函数

//无参构造
list l1;

//区间拷贝构造函数
list l2(l1.begin(),l1.end());

//拷贝构造函数
 list l3(l2);

list_2:赋值操作

//直接赋值操作
list l1; //无参构造
list l2;
l2 = l1;

//区间拷贝赋值，这种方法使用比较少。
list l3;
l3.assign(l1.begin(), l1.end());

list_3:大小操作

listL1;
//判断容器是否为空
L1.empty()；

//判断元素个数
L1.size();

//重新指定大小
L1.resize(10);

list_4:插入与删除

list L;
//头删
L.pop_front();

//插入
list::iterator it = L.begin();
L.insert(++it, 1000);

//删除
it = L.begin();
L.erase(++it);

//删除容器中所有的1000
L.remove(10000);

//清空
L.clear();

list_5:list内部的其他算法

list l1;
list l2;
//容器交换
l1.swap(l2);

//容器反转
l1.reverse();

//容器从小到大排序
 l1.sort();

//容器从大到小排序
bool myCompare(int v1,int v2){
    return v1>v2;
}
l1.sort(myCompare);

6.set容器

set_1:set的构造函数

//无参构造
set s1;

//拷贝构造函数
sets2(s1);

set_2:set赋值操作

set s1;
sets3;
s3 = s1;

set_3:大小操作

set s1;
//容器是否为空
s1.empty();

//容器元素大小
s1.size();

//清空
s1.clear();

set_4：容器内部其他算法

set s1;
set s2;
//容器交换
s1.swap(s2);

//通过容器中元素3的个数
int num=s1.cout(3);

//查找容器中是否有元素30
set::iterator pos = s1.find(30);

if (pos != s1.end())
{
	cout << "找到了元素 ： " << *pos << endl;
}
else
{
	cout << "未找到元素" << endl;
}

7.map容器

map_1：map的构造函数

//默认构造函数
map m;

拷贝构造
map m2(m); 

map_2: 赋值操作

map m1;
map m3;
m3 = m1;

map_3:大小操作

map m;
//容器是否为空
map.empty();

//容器元素多少
m.size();

//清空
m.clear();

map_4:插入与删除

map m;
//第一种插入方式
m.insert(pair(1, 10));
//第二种插入方式
m.insert(make_pair(2, 20));
//第三种插入方式
m.insert(map::value_type(3, 30));
//第四种插入方式，不建议使用
m[4] = 40; 

//删除第一个元素
m.erase(m.begin());

//删除容器中的3
m.erase(3);

map_5:容器内部其他算法

map<int, int>m;
map<int, int>m1;
//容器交换
m.swap(m1);

//查找
map<int, int>::iterator pos = m.find(3);
if (pos != m.end())
{
     
	cout << "找到了元素 key = " << (*pos).first << " value = " << (*pos).second << endl;
}
else
{
     
	cout << "未找到元素" << endl;
}

//统计
int num = m.count(3);