c++學習--詳細帶你了解不同容器之間的常用方法與不同之處。

學習視頻：黑馬程式員匠心之作|C++教程從0到1入門編程,學習編程不再難
因為可能會因為不同容器而有不同的頭檔案，為了方便我們直接使用萬能頭檔案：

#include <bits/stdc++.h>

常用容器總結與對比：
因為有些代碼過長，表格無法完全表示，我用名字來代替，可以在下面找到相應的代碼，例如：vector_1，可以在下方找到vector的建構式，

1.vector容器

vector_1：vector建構式：

vector<int> v1; //無參構造;
vector<int> v2(v1.begin(), v1.end());//區間拷貝建構式;
vector<int> v3(v2);//拷貝建構式

vector_2:賦值操作

//直接賦值操作
vector<int> v1; //無參構造
vector<int>v2;
v2 = v1;

//區間拷貝賦值，這種方法使用比較少，
vector<int>v3;
v3.assign(v1.begin(), v1.end());

vector_3:vector的大小與容量操作

vector<int> v1;
//判斷容器是否為空
v1.empty();
//容器的容量
v1.capacity();
//容器元素個數
v1.size();
//重新指定容器大小
v1.resize(2);

vector_4:vector的洗掉與插入操作

//迭代器指向位置v1.begin()前插入元素100
vector<int> 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<int> d1; //無參建構式
deque<int> d2(d1.begin(), d1.end());//區間拷貝建構式;
deque<int> d3(d2);//拷貝建構式

deque_2:賦值操作

//直接賦值操作
deque<int> d1; //無參構造
deque<int>d2;
d2 = d1;

//區間拷貝賦值，這種方法使用比較少，
deque<int>d3;
d3.assign(d1.begin(), d1.end());

deque_3:大小操作

deque<int> d1;
//判斷容器是否為空
d1.empty();
//容器元素個數
d1.size();
//重新指定容器大小
d1.resize(2);

deque_4:deque的洗掉與插入操作

//在d1.begin()前位置插入一個1000
deque<int> 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<int> s1; //無參建構式
stack<int> s2(s1); //拷貝建構式

stack_2:賦值操作

//直接賦值操作，無拷貝賦值操作
stack<int> s1;
stack<int> s2;
s2=s1;

stack_3:大小操作

//判斷s1是否為空
stack<int> s1;
s1.empty();

//判斷s1的元素個數
s1.size();

4.queue容器

queue_1:queue的建構式

因為queue佇列中只有隊頭和隊尾才可以被外界使用，因此佇列不允許有遍歷行為，begin和end方法都不能使用，所有沒有區間拷貝建構式，

queue<int> q1; //無參建構式
queue<int> q2(q1); //拷貝建構式

queue_2:賦值操作

//直接賦值操作
queue<int> q1; //無參構造
queue<int> q2;
q2 = q1;

queue_3:大小操作

//判斷是否為空
queue<int> q1;
q1.empty();

//判斷元素個數
q1.size();

5.list容器

list_1:list的建構式

//無參構造
list<int> l1;

//區間拷貝建構式
list<int> l2(l1.begin(),l1.end());

//拷貝建構式
 list<int> l3(l2);

list_2:賦值操作

//直接賦值操作
list<int> l1; //無參構造
list<int> l2;
l2 = l1;

//區間拷貝賦值，這種方法使用比較少，
list<int> l3;
l3.assign(l1.begin(), l1.end());

list_3:大小操作

list<int>L1;
//判斷容器是否為空
L1.empty()；

//判斷元素個數
L1.size();

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

list_4:插入與洗掉

list<int> L;
//頭刪
L.pop_front();

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

//洗掉
it = L.begin();
L.erase(++it);

//洗掉容器中所有的1000
L.remove(10000);

//清空
L.clear();

list_5:list內部的其他演算法

list<int> l1;
list<int> 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<int> s1;

//拷貝建構式
set<int>s2(s1);

set_2:set賦值操作

set<int> s1;
set<int>s3;
s3 = s1;

set_3:大小操作

set<int> s1;
//容器是否為空
s1.empty();

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

//清空
s1.clear();

set_4：容器內部其他演算法

set<int> s1;
set<int> s2;
//容器交換
s1.swap(s2);

//通過容器中元素3的個數
int num=s1.cout(3);

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

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

7.map容器

map_1：map的建構式

//默認建構式
map<int,int> m;

拷貝構造
map<int, int> m2(m); 

map_2: 賦值操作

map<int> m1;
map<int> m3;
m3 = m1;

map_3:大小操作

map<int,int> m;
//容器是否為空
map.empty();

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

//清空
m.clear();

map_4:插入與洗掉

map<int, int> m;
//第一種插入方式
m.insert(pair<int, int>(1, 10));
//第二種插入方式
m.insert(make_pair(2, 20));
//第三種插入方式
m.insert(map<int, int>::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);