久久国产成人av_抖音国产毛片_a片网站免费观看_A片无码播放手机在线观看,色五月在线观看,亚洲精品m在线观看,女人自慰的免费网址,悠悠在线观看精品视频,一级日本片免费的,亚洲精品久,国产精品成人久久久久久久

搜索
分享

STL容器的常用方法

 CodeNutter 2016-07-24

以下內(nèi)容如有錯誤,，歡迎指出。

STL容器都是以類模板的形式實現(xiàn)的,，所以在使用之前必須用類型進行實例化為具體的模板類

vector

以int類型實例化

vector<int> vec1;//構(gòu)造空的vector
vector<int> vec2(10);//構(gòu)造大小為10,，值按照默認初始化規(guī)則默認初始化
vector<int> vec3(10, 1);//構(gòu)造大小為10，初始值為1
vector<int> vec4(vec2);//通過拷貝vec2來構(gòu)造
vector<int> vec5(vec3.begin(), vec3.end);//用[First,last)之間的元素來構(gòu)造

vec1=vec2;//賦值操作
vec1.size();//返回vec1的大小,，這里為10
vec1.empty();//判斷vec1是否為空,，為空返回true，否則返回false
vec1.at(n);//返回vec1中的第n個元素的引用,，會判斷是否越界
vec1[n];//返回vec1中的第n個元素的引用,，不會判斷是否越界
vec1.front();//返回vec1中的頭元素的引用
vec1.back();//返回vec1中的最后一個元素的引用
vec1.push_back(1);//在vec1的最后插入值為1的元素，可能會引起空間從新分配
vec1.pop_back();//刪除vec1的最后一個元素
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

注意：vector沒有pop_front和push_front操作

vector<int>::iterator it1=vec1.begin();//返回頭迭代器
vector<int>::iterator it2=vec1.end();//返回尾后迭代器
vector<int>::iterator it3=vec1.rbegin();//返回尾后迭代器
vector<int>::iterator it4=vec1.rend();//返回頭迭代器
  • 1
  • 2
  • 3
  • 4

注意：插入操作都是在position（哨兵迭代器）之前插入

vector<int>::iterator it=vec1.insert(2,4);//在vec1第三個元素之前插入值為4的元素,，返回插入元素的迭代器
vec1.insert(2,3,4);//在vec1的第三個元素之前插入3個值為4的元素,，返回void
vec1.insert(2,vec3.begin(),vec3.end());//在vec1的第3個元素之前插入[First,last)
vec1.assign(vec3.begin(),vec3.begin()+5);//將vec3的前5個元素賦值給vec1前5個元素
vec1.erase(1);//刪除vec1的第2個元素，其實真實操作是把后面的元素依次向前復制
vec1.erase(vec1.begin(),vec.begin()+2);//刪除迭代器范圍內(nèi)的元素
vec1.clear();//刪除所有元素

vec1.swap(vec2);//交換兩個vector
vec1.reserve(20);//重新分配大小為20
vec1.capacity();//返回當前分配的存儲空間的長度（這個可能比實際需求的空間大）
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

注意：

  • vector分配的空間是連續(xù)的
  • vector插入元素,，如果不引起空間重新分配,，會使插入位置以后的迭代器全部失效。如果引起空間重新分配,，所有迭代器都會失效,。
  • 刪除元素，會使當前位置及后面的所有迭代器失效,。
  • vector的迭代器是Random Access itreator,，可以說是類似一般指針，在侯捷的《STL的源碼剖析》中typedef value_type* iterator,。而在VS中就是類似一般指針,，由于屬于派生類，sizeof大小為12,。但是總體來說都支持一般指針的所有操作,。

list

以int類型實例化

list<int> l1;//構(gòu)造一個空list
list<int> l2(10,1);//構(gòu)造大小為10，元素值為1
list<int> l3(l2);//通過拷貝l2來構(gòu)造
list<int> l4(l3.begin(), l3.begin()+5);//用[first,last)來構(gòu)造


l1=l2;//賦值操作
l2.resize(20);//將l2的大小變?yōu)?0,，在以前l(fā)ist尾節(jié)點后面追加int()元素,，若大小比以前小直接從后刪除多余的節(jié)點
l2.resize(25,2);//將l2大小變?yōu)?5，增加的元素的值為2,，若大小比以前小直接從后刪除多余的節(jié)點
l1.size();//返回l1的大小
l1.empty();//判斷是否為空,，為空，返回true,；否則返回false


l1.front();//返回第一個元素的引用
l1.back();//返回最后一個元素的引用
l1.push_front(5);//在第一個位置之前插入一個值為5元素,，返回void
l1.pop_front();//刪除第一個元素，返回void
l1.push_back(5);//插入一個值為5的元素到最后,，返回void
l1.pop_back();//刪除最后一個元素,，返回void


list<int>::iterator it1;
it1=l1.begin();//返回起始迭代器，頭的下一個,，list源碼實現(xiàn)中head是一個空節(jié)點
l1.end();//返回尾后迭代器
l1.rbegin();//返回尾后迭代器
l1.rend();//返回頭迭代器


l2.insert(l2.end(), 2);//在l2的尾端插入一個值為2的元素,，返回指向插入元素的迭代器
l2.insert(l2.begin(), 4, 3);//在l2的起始位置插入4個值為3的元素，返回void
l2.insert(l2.begin(), l1.begin(), l1.end());//在l2的起始位置插入l1的區(qū)間[first,last),，返回void
l2.assign(l1.begin(), l1.begin()+3);//用[first,last)重新給l2賦值,，先刪除l2的所有元素再插入
l2.assign(5,4);//先刪除l2的所有元素再插入5個值為4的元素
l2.erase(l2.begin());//刪除l2的第一個元素，返回下一個迭代器
l2.erase(l2.begin(), l2.begin()+2);//刪除[first,last)區(qū)間元素,，返回指向刪除區(qū)間的下一個元素的迭代器
l2.clear();//刪除所有元素
l1.remove(5);//刪除所有元素之等于5的節(jié)點,，返回void
l1.remove_if(predicate);//刪除所有讓一元謂詞為true的元素
l1.unique();//刪除每一個和前一個元素相同的元素


l3.sort();//用<操作排序
l4.sort(predicate);//用滿足謂詞的順序排序
l3.merge(l4);//合并l4到l3（要求兩個鏈表都為有序隊列，按遞增排序）
l1.swap(l3);//交換l1和l3,，返回void
l1.splice(l1.begin()+1, l3);//將l3拼接在l1.begin()+1之后,，返回void
l1.splice(l1.begin(), l4, l4.begin());//將l4.begin()所指節(jié)點拼接到l1的第一個節(jié)點之后，返回void
l1.splice(l1.begin(), l5.begin(), l5.end());//將[first,last)拼接到l1的第一個節(jié)點之后,，返回void
l1.reverse();//倒置鏈表
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

list的迭代器型別是Bidirectional iterator

list<int>::iterator it=l1.begin();//list的迭代器支持以下操作
operator*();
operator->();
operator++();//前自加
operator++(int);//后自加
operator--();
operator--(int);
operator==();
operator!=();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

注意

  • list分配的空間是非連續(xù)空間
  • list巧妙的實現(xiàn)為一個環(huán)狀鏈表,，鏈表的head為一個空節(jié)點
  • list的插入操作不會造成迭代器失效,，刪除操作只會使指向被刪除元素的迭代器失效

deque（雙端隊列）

以int類型實例化

deque<int> deq1;//構(gòu)造一個空deque
deque<int> deq2(10);//構(gòu)造大小為10的deque，值為int()
deque<int> deq3(10,4);//大小為10,，值為4
deque<int> deq4(deq3);//拷貝構(gòu)造
deque<int> deq5(deq4.begin(), deq4.end());//拷貝[first,last)來構(gòu)造


deq1=deq2;//賦值
deq1.begin();//返回頭迭代器
deq1.end();//返回尾后迭代器
deq1.rbegin();//返回尾后迭代器
deq1.rend();//返回頭迭代器


deq1.resize(15);//重新分配大小,，并在后面填補值為int()的元素
deq1.resize(20,4);//重新分配大小，并在后面填補值為4的元素
deq1.size();//返回隊列大小
deq1.empty();//判斷隊列是否為空,，為空返回true,，否則返回false


deq1.at(5);//返回位置為5的元素的引用，以0為基準
deq1[5];//返回位置為5的元素的引用,，以0為基準
deq1.front();//返回第一個元素的引用
deq1.back();//返回最后一個元素的引用
deq1.push_front(4);//在隊列頭的位置插入一個值為4的元素
deq1.pop_front();//刪除隊列的第一個元素
deq1.push_back(4);//在隊列的最后
deq1.pop_back();//刪除隊列的最后一個元素


deq2.assign(deq1.begin(), deq1.begin()+10);//用[first,last)來賦值,，先刪除所有元素
deq2.assign(10,3);//先刪除所有元素，再分配10個大小,，值為3
deq2.insert(deq2.begin(), 7);//在隊列頭插入值為7的元素
deq2.insert(deq2.begin(), 3, 7);//在隊列頭插入3個值為7的元素
deq2.insert(deq2.begin(), deq1.begin(),deq1.begin()+4);//插入[first,last)
deq2.erase(deq2.begin());//刪除迭代器所指元素
deq2.erase(deq2.begin(),deq2.begin()+3);//刪除[first,last)區(qū)間元素
deq2.clear();//刪除所有元素
deq3.swap(deq1);//交換兩個隊列
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

deque的迭代器型別是Random Access iterator

deque<int>::iterator it=deq1.begin();//deque的迭代器支持以下操作
operator*();
operator->();
operator++();//前自加
operator++(int);//后自加
operator--();
operator--(int);
operator+();
operator+=();
operator-();
operator-=();
operator[]();
operator==();
operator!=();
operator>();
operator<();
operator>=();
operator<=();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

注意

  • deque分配的空間是分段定量連續(xù)空間,，為了維持整體連續(xù)的假象，采用一塊map（一小塊連續(xù)空間）,，其中每個元素（node）都是指針,，指向另一段較大的連續(xù)線性空間，稱為緩沖區(qū),，這才是存儲空間主體,。
  • deque的迭代器型別是Random Access iterator，實現(xiàn)起來比vector的迭代器復雜,。
  • deque插入元素到首尾時,，會使首尾迭代器失效，但是指向元素的引用和指針不會失效,，插入到除首尾之外的其他位置會導致迭代器,、引用和指針失效。刪除首尾元素,，會使首尾迭代器失效,，刪除首尾之外的其他位置的元素會導致迭代器、引用和指針失效,。

queue（先進先出,，底端進頂端出）

queue的默認底層實現(xiàn)容器是deque

以int類型實例化

queue<int> que1;//構(gòu)造空的queue
queue<int> que2(deque<int>(5,3));//deque容器來構(gòu)造

que1.empty();//判斷是否為空，為空返回true,，否則返回false
que1.size();//返回隊列大小
que1.front();//返回隊列的第一個元素的引用
que1.back();//返回隊列最后一個元素的引用
que1.push(1);//從底端插入
que1.pop();//從頂端刪除,，返回void
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

注意：queue只能從頭尾訪問元素，不提供迭代器,，不能遍歷,。

priority_queue(優(yōu)先隊列)

默認底層實現(xiàn)容器為vector，默認用最大堆（max-heap）完成優(yōu)先

以int類型實例化

priority_queue<int> prique1;//構(gòu)造空的優(yōu)先隊列
priority_queque<int> prique2(vec1.begin(), vec1.end());//用一個vector的[first,last)區(qū)間來構(gòu)造

prique2.empty();//判斷隊列是否為空
prique2.size();//
prique2.top();//返回最高優(yōu)先級元素的引用
prique2.push(1);//插入值為1的元素，會進行堆排序
prique2.pop();//刪除最高優(yōu)先級元素
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

注意：priority_queue只有頂端元素才能被外界取用,，不提供迭代器,，不提供遍歷

stack(先進后出，頂端出入)

默認底層實現(xiàn)容器deque

以int類型實例化

stack<int> sta1;//構(gòu)造一個空的stack
stack<int> sta2(deque<int>(5,3));//用deque容器構(gòu)造

sta2.empty();
sta2.size();
sta2.top();//返回頂端元素的引用
sta2.push(1);//從頂端插入值為1的元素
sta2.pop();//從頂端刪除元素
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

注意：stack是先進先出的數(shù)據(jù)結(jié)構(gòu),，只能從頂端存取元素,，不提供迭代器,，不提供遍歷

map

map的實現(xiàn)分兩種：繼承rb_tree實現(xiàn),、組合rb_tree實現(xiàn)

  • 底層以RB_tree(紅黑樹)實現(xiàn)key排序，每個節(jié)點的值叫value_type,。默認用了less<key_type>模板函數(shù)作為key_compare,。
  • map要注意區(qū)分key_type，value_type,，mapped_type,。其中value_type=pair<cosnt key_type, mapped_type>
  • map的模板聲明：
    template<class _Kty,//鍵值類型
    class _Ty,//映射值類型
    class _Pr = less<_Kty>,//鍵值比較仿函數(shù)類型,默認less
    class _Alloc = allocator<pair<const _Kty, _Ty> > >//配置器類型
    class map;
map<string, int> students1;//構(gòu)造一個空的map
map<string, int> students2;//
  • 1
  • 2

注意：用insert向map中插入元素時，采用的底層機制rb_tree的insert_unique()實現(xiàn),。如果已經(jīng)有鍵值相等的元素則插入失敗,，如果沒有相同鍵值的元素存在則插入。operator[]操作,，先查找map中是否有相同鍵值,，如果有就返回mapped_type的引用，如果沒有就插入mapped_type(),也就是默認值,，然后返回mapped_type的引用,。插入操作和刪除操作都會進行紅黑樹的調(diào)整，但是只會使當前迭代器失效,，對其他迭代器沒有影響

students1["xiaoming"]=9;//相當于查找或插入xiaoming,，對返回的mapped引用賦值
students1.insert(pair<string,int>("xiaohong",10));//插入一個pair
students1.insert(make_pair("xiaozhang",11));//插入一個pair
students1.insert(map<string,int>::value_type("xiaoli,10"));

students2=students1;//賦值運算
map<string,int>::iterator it=students2.begin();//返回map的第一個迭代器
students1.end();//返回map的尾后迭代器

students2.erase(it);//刪除it迭代器所指的元素，返回指向下一個元素的迭代器
students2.erase("xiaoli");//刪除students2中鍵值和“xiaoli”相同的元素,，返回刪除的所有匹配元素的個數(shù)
students2.erase(students2.begin(),students2.begin()+1);刪除[first,last)區(qū)間元素
students2.clear();//刪除所有元素

students1.size();//返回map容器的大小
students1.empty();//判斷map容器是否為空
students1.find("xiaoming");//返回指向配置鍵值元素的迭代器,，如果沒有找到就返回尾后迭代器
students1.count("xiaoming");//返回所有鍵值匹配元素的個數(shù)
students1.lower_bound("xiaoming");//返回指向最左端不小于這個鍵值的元素的迭代器（這里的例子不合適用這個方法,單單說明這個方法的用法）
students1.upper_bound("xiaoming");//返回指向最左端大于這個鍵值的元素的迭代器
students1.swap(students2);//交換兩個map
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

map的迭代器型別是bidirectional iterator，自增自減都是通過rb_tree的迭代器的內(nèi)部函數(shù)實現(xiàn)的

map的迭代器支持以下主要操作
operator*();
operator->();
operator++();//前自加
operator++(int);//后自加
operator--();
operator--(int);
operator==();
operator!=();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

注意

  • map分配的節(jié)點空間是非連續(xù)空間,。每個節(jié)點也就是紅黑樹的節(jié)點,，包括left，right,，parent,，color，value_type成員變量,。
  • map的迭代器型別是bidirectional access iterator,，實現(xiàn)起來比list的迭代器復雜。
  • map插入操作不會造成迭代器失效，刪除操作只會使指向被刪除元素的迭代器失效,。
  • operator[]操作,，先查找map中是否有相同鍵值，如果有就返回mapped_type的引用,，如果沒有就插入mapped_type(),也就是默認值,，然后返回mapped_type的引用。

set

set的實現(xiàn)和map一樣也分兩種：繼承rb_tree實現(xiàn),、組合rb_tree實現(xiàn)

  • 底層以RB_tree(紅黑樹)實現(xiàn)key排序,，只有鍵值，key_type和value_type是一樣的,。默認用了less<key_type>模板函數(shù)作為key_compare,。
  • set的模板聲明：
    template<class _Kty,//健
    class _Pr = less<_Kty>,//用于排序比較仿函數(shù)
    class _Alloc = allocator<_Kty> >
    class set；
int array[5]={0,1,2,3,4};
set<int> orderset1(array,array+5);//用[first,last)構(gòu)造一個set
set<int> orderset2;//構(gòu)造一個空的set
  • 1
  • 2
  • 3

注意：用insert向set中插入元素時,，采用的底層機制rb_tree的insert_unique()實現(xiàn),。如果已經(jīng)有鍵值相等的元素則插入失敗，如果沒有相同鍵值的元素存在則插入,。插入操作和刪除操作都會進行紅黑樹的調(diào)整,，但是只會使當前迭代器失效，對其他迭代器沒有影響

orderset1.insert(10);//插入一個鍵值為10的元素
orderset2=orderset1;//賦值運算
set<int>::iterator it=orderset1.begin();//返回set的第一個迭代器
orderset1.end();//返回set的尾后迭代器

orderset1.erase(it);//刪除it迭代器所指的元素,，返回指向下一個元素的迭代器
orderset1.erase(0);//刪除orderset1中鍵值為0相同的元素,，返回刪除的所有匹配元素的個數(shù)
orderset1.erase(orderset1.begin(),orderset1.begin()+1);刪除[first,last)區(qū)間元素
orderset1.clear();//刪除所有元素

orderset2.size();//返回set容器的大小
orderset2.empty();//判斷set容器是否為空
orderset2.find(4);//返回指向鍵值為4的元素的迭代器，如果沒有找到就返回尾后迭代器
orderset2.count(2);//返回所有鍵值匹配元素的個數(shù)
orderset2.lower_bound(3);//返回指向最左端不小于這個鍵值的元素的迭代器
orderset2.upper_bound(4);//返回指向最左端大于這個鍵值的元素的迭代器
orderset2.swap(orderset1);//交換兩個set
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

set的迭代器型別是bidirectional iterator,，自增自減都是通過rb_tree的迭代器的內(nèi)部函數(shù)實現(xiàn)的

set的迭代器支持以下主要操作
operator*();
operator->();
operator++();//前自加
operator++(int);//后自加
operator--();
operator--(int);
operator==();
operator!=();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

注意

  • set分配的節(jié)點空間是非連續(xù)空間,。每個節(jié)點也就是紅黑樹的節(jié)點，包括left,，right,，parent，color,，value_type成員變量,。
  • set的迭代器型別是bidirectional access iterator，實現(xiàn)起來比list的迭代器復雜,。
  • set插入操作不會造成迭代器失效,，刪除操作只會使指向被刪除元素的迭代器失效。

multimap

multimap的特性和用法與map基本相同,，差別在于它允許鍵值重復,，因此它的插入操作采用的底層機制rb_tree的insert_equal()而非insert_unique()。還有就是multimap不支持operator[]操作,。

multiset

multiset的特性和用法與set完全相同,，唯一的差別在于它允許鍵值重復，因此它的插入操作采用的底層機制rb_tree的insert_equal()而非insert_unique()。

    本站是提供個人知識管理的網(wǎng)絡存儲空間,，所有內(nèi)容均由用戶發(fā)布,，不代表本站觀點。請注意甄別內(nèi)容中的聯(lián)系方式,、誘導購買等信息,，謹防詐騙。如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容,，請點擊一鍵舉報,。
    轉(zhuǎn)藏 分享 獻花（0）

    0條評論

    發(fā)表

    請遵守用戶 評論公約

    類似文章 更多