當前位置：首頁 > 编程语言 > c/c++ >内容正文

c/c++

[转]【C/C++】STL详解

發布時間：2024/3/13 c/c++ 24 豆豆

生活随笔收集整理的這篇文章主要介紹了 [转]【C/C++】STL详解小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

? 轉載備用，原創作者在文章結尾。。。

文章目錄

概述
STL六大組件簡介
三大組件介紹
- 1. 容器
- 2. 算法
- 3. 迭代器
常用容器
- 1. string容器
- - string容器基本概念
  - string容器常用操作
- 2. vector容器
- - vector容器基本概念
  - vector迭代器
  - vector的數據結構
  - vector常用API操作
- 3. deque容器
- - deque容器基本概念
  - deque容器實現原理
  - deque常用API
- 4. stack容器
- - stack容器基本概念
  - stack沒有迭代器
  - stack常用API
- 5. queue容器
- - queue容器基本概念
  - queue沒有迭代器
  - queue常用API
- 6. list容器
- - list容器的迭代器
  - list容器的數據結構
  - list常用API
- 7. set/multiset容器
- - set容器基本概念
  - multiset容器基本概念
  - set常用API
  - 對組(pair)
- 8. map/multimap容器
- - map/multimap基本概念
  - map/multimap常用API
- STL容器使用時機
常用算法
- 1. 函數對象
- 2. 謂詞
- 3.內建函數對象
- 4. 函數對象適配器
- 算法概述
- - 1. 常用遍歷算法
  - 2. 常用查找算法
  - 3. 常用排序算法
  - 4. 常用拷貝和替換算法
  - 5. 常用算數生成算法
  - 6. 常用集合算法

概述

長久以來，軟件界一直希望建立一種可重復利用的東西，以及一種得以制造出”可重復運用的東西”的方法，從函數(functions)，類別(classes),函數庫(function libraries),類別庫(class libraries)、各種組件，從模塊化設計，到面向對象(object oriented )，為的就是復用性的提升。

復用性必須建立在某種標準之上。但是在許多環境下，就連軟件開發最基本的數據結構(data structures) 和算法(algorithm)都未能有一套標準。大量程序員被迫從事大量重復的工作，竟然是為了完成前人已經完成而自己手上并未擁有的程序代碼，這不僅是人力資源的浪費，也是挫折與痛苦的來源。

為了建立數據結構和算法的一套標準，并且降低他們之間的耦合關系，以提升各自的獨立性、彈性、交互操作性(相互合作性,interoperability),誕生了STL。

STL(Standard Template Library,標準模板庫)，是惠普實驗室開發的一系列軟件的統稱。現在主要出現在 c++中，但是在引入 c++之前該技術已經存在很長時間了。

STL 從廣義上分為: 容器(container) 算法(algorithm) 迭代器(iterator)。

容器和算法之間通過迭代器進行無縫連接。STL 幾乎所有的代碼都采用了模板類或者模板函數，這相比傳統的由函數和類組成的庫來說提供了更好的代碼重用機會。

STL(Standard Template Library)標準模板庫,在我們 c++標準程序庫中隸屬于 STL 的占到了 80%以上。

STL六大組件簡介

STL提供了六大組件，彼此之間可以組合套用，這六大組件分別是:容器、算法、迭代器、仿函數、適配器（配接器）、空間配置器。

容器：各種數據結構，如vector、list、deque、set、map等,用來存放數據，從實現角度來看，STL容器是一種class template。

算法：各種常用的算法，如sort、find、copy、for_each。從實現的角度來看，STL算法是一種function tempalte.

迭代器：扮演了容器與算法之間的膠合劑，共有五種類型，從實現角度來看，迭代器是一種將operator* , operator-> , operator++,operator–等指針相關操作予以重載的class template. 所有STL容器都附帶有自己專屬的迭代器，只有容器的設計者才知道如何遍歷自己的元素。原生指針(native pointer)也是一種迭代器。

仿函數：行為類似函數，可作為算法的某種策略。從實現角度來看，仿函數是一種重載了operator()的class 或者class template

適配器：一種用來修飾容器或者仿函數或迭代器接口的東西。

空間配置器：負責空間的配置與管理。從實現角度看，配置器是一個實現了動態空間配置、空間管理、空間釋放的class tempalte.

STL六大組件的交互關系，容器通過空間配置器取得數據存儲空間，算法通過迭代器存儲容器中的內容，仿函數可以協助算法完成不同的策略的變化，適配器可以修飾仿函數。

STL的優點很明顯了：

STL 是 C++的一部分，因此不用額外安裝什么，它被內建在你的編譯器之內。
STL 的一個重要特性是將數據和操作分離。數據由容器類別加以管理，操作則由可定制的算法定義。迭代器在兩者之間充當“粘合劑”,以使算法可以和容器交互運作
程序員可以不用思考 STL 具體的實現過程，只要能夠熟練使用 STL 就 OK 了。這樣他們就可以把精力放在程序開發的別的方面。
STL 具有高可重用性，高性能，高移植性，跨平臺的優點。
- 高可重用性：STL 中幾乎所有的代碼都采用了模板類和模版函數的方式實現，這相比于傳統的由函數和類組成的庫來說提供了更好的代碼重用機會。
- 高性能：如 map 可以高效地從十萬條記錄里面查找出指定的記錄，因為 map 是采用紅黑樹的變體實現的。
- 高移植性：如在項目 A 上用 STL 編寫的模塊，可以直接移植到項目 B 上。

三大組件介紹

1. 容器

幾乎可以說，任何特定的數據結構都是為了實現某種特定的算法。STL容器就是將運用最廣泛的一些數據結構實現出來。
常用的數據結構：數組(array) , 鏈表(list), tree(樹)，棧(stack), 隊列(queue), 集合(set),映射表(map), 根據數據在容器中的排列特性，這些數據分為序列式容器和關聯式容器兩種。

序列式容器強調值的排序，序列式容器中的每個元素均有固定的位置，除非用刪除或插入的操作改變這個位置。Vector容器、Deque容器、List容器等。
關聯式容器是非線性的樹結構，更準確的說是二叉樹結構。各元素之間沒有嚴格的物理上的順序關系，也就是說元素在容器中并沒有保存元素置入容器時的邏輯順序。關聯式容器另一個顯著特點是：在值中選擇一個值作為關鍵字key，這個關鍵字對值起到索引的作用，方便查找。Set/multiset容器 Map/multimap容器

2. 算法

算法，問題的解法，以有限的步驟，解決邏輯或數學上的問題。

我們所編寫的每個程序都是一個算法，其中的每個函數也都是一個算法，畢竟它們都是用來解決或大或小的邏輯問題或數學問題。STL收錄的算法經過了數學上的效能分析與證明，是極具復用價值的，包括常用的排序，查找等等。特定的算法往往搭配特定的數據結構，算法與數據結構相輔相成。

算法分為:質變算法和非質變算法。

質變算法：是指運算過程中會更改區間內的元素的內容。例如拷貝，替換，刪除等等
非質變算法：是指運算過程中不會更改區間內的元素內容，例如查找、計數、遍歷、尋找極值等等

3. 迭代器

迭代器(iterator)是一種抽象的設計概念，現實程序語言中并沒有直接對應于這個概念的實物。在<<Design Patterns>>一書中提供了23種設計模式的完整描述，其中iterator模式定義如下：提供一種方法，使之能夠依序尋訪某個容器所含的各個元素，而又無需暴露該容器的內部表示方式。

迭代器的設計思維-STL的關鍵所在，STL的中心思想在于將容器(container)和算法(algorithms)分開，彼此獨立設計，最后再一貼膠著劑將他們撮合在一起。

從技術角度來看，容器和算法的泛型化并不困難，c++的class template和function template可分別達到目標，如果設計出兩這個之間的良好的膠著劑，才是大難題。

迭代器的種類:

迭代器功能描述

輸入迭代器	提供對數據的只讀訪問	只讀，支持++、==、！=
輸出迭代器	提供對數據的只寫訪問	只寫，支持++
前向迭代器	提供讀寫操作，并能向前推進迭代器	讀寫，支持++、==、！=
雙向迭代器	提供讀寫操作，并能向前和向后操作	讀寫，支持++、–，
隨機訪問迭代器	提供讀寫操作，并能以跳躍的方式訪問容器的任意數據，是功能最強的迭代器	讀寫，支持++、–、[n]、-n、<、<=、>、>=

演示

#define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<vector> #include<algorithm> using namespace std;//STL 中的容器算法迭代器 void test01(){vector<int> v; //STL 中的標準容器之一：動態數組v.push_back(1); //vector 容器提供的插入數據的方法v.push_back(5);v.push_back(3);v.push_back(7);//迭代器vector<int>::iterator pStart = v.begin(); //vector 容器提供了 begin()方法返回指向第一個元素的迭代器vector<int>::iterator pEnd = v.end(); //vector 容器提供了 end()方法返回指向最后一個元素下一個位置的迭代器//通過迭代器遍歷while (pStart != pEnd){cout << *pStart << " ";pStart++;}cout << endl;//算法 count 算法用于統計元素的個數int n = count(pStart, pEnd, 5);cout << "n:" << n << endl; } //STL 容器不單單可以存儲基礎數據類型，也可以存儲類對象 class Teacher { public:Teacher(int age) :age(age){};~Teacher(){}; public:int age; }; void test02(){vector<Teacher> v; //存儲 Teacher 類型數據的容器Teacher t1(10), t2(20), t3(30);v.push_back(t1);v.push_back(t2);v.push_back(t3);vector<Teacher>::iterator pStart = v.begin();vector<Teacher>::iterator pEnd = v.end();//通過迭代器遍歷while (pStart != pEnd){cout << pStart->age << " ";pStart++;}cout << endl; } //存儲 Teacher 類型指針 void test03(){vector<Teacher*> v; //存儲 Teacher 類型指針Teacher* t1 = new Teacher(10);Teacher* t2 = new Teacher(20);Teacher* t3 = new Teacher(30);v.push_back(t1);v.push_back(t2);v.push_back(t3);//拿到容器迭代器vector<Teacher*>::iterator pStart = v.begin();vector<Teacher*>::iterator pEnd = v.end();//通過迭代器遍歷while (pStart != pEnd){cout << (*pStart)->age << " ";pStart++;}cout << endl; } //容器嵌套容器難點 void test04() {vector< vector<int> > v;vector<int>v1;vector<int>v2;vector<int>v3;for (int i = 0; i < 5;i++){v1.push_back(i);v2.push_back(i * 10);v3.push_back(i * 100);}v.push_back(v1);v.push_back(v2);v.push_back(v3);for (vector< vector<int> >::iterator it = v.begin(); it != v.end();it++){for (vector<int>::iterator subIt = (*it).begin(); subIt != (*it).end(); subIt ++){cout << *subIt << " ";}cout << endl;} } int main(){//test01();//test02();//test03();test04();system("pause");return EXIT_SUCCESS; }

常用容器

1. string容器

string容器基本概念

C風格字符串(以空字符結尾的字符數組)太過復雜難于掌握，不適合大程序的開發，所以C++標準庫定義了一種string類，定義在頭文件<string>。
String和c風格字符串對比：

Char*是一個指針，String是一個類
string封裝了char*，管理這個字符串，是一個char*型的容器。
String封裝了很多實用的成員方法
查找find，拷貝copy，刪除delete 替換replace，插入insert
不用考慮內存釋放和越界
string管理char*所分配的內存。每一次string的復制，取值都由string類負責維護，不用擔心復制越界和取值越界等。

string容器常用操作

string 構造函數

string();//創建一個空的字符串例如: string str; string(const string& str);//使用一個string對象初始化另一個string對象 string(const char* s);//使用字符串s初始化 string(int n, char c);//使用n個字符c初始化

string基本賦值操作

string& operator=(const char* s);//char*類型字符串賦值給當前的字符串 string& operator=(const string &s);//把字符串s賦給當前的字符串 string& operator=(char c);//字符賦值給當前的字符串 string& assign(const char *s);//把字符串s賦給當前的字符串 string& assign(const char *s, int n);//把字符串s的前n個字符賦給當前的字符串 string& assign(const string &s);//把字符串s賦給當前字符串 string& assign(int n, char c);//用n個字符c賦給當前字符串 string& assign(const string &s, int start, int n);//將s從start開始n個字符賦值給字符串

string存取字符操作

char& operator[](int n);//通過[]方式取字符 char& at(int n);//通過at方法獲取字符

string拼接操作

string& operator+=(const string& str);//重載+=操作符 string& operator+=(const char* str);//重載+=操作符 string& operator+=(const char c);//重載+=操作符 string& append(const char *s);//把字符串s連接到當前字符串結尾 string& append(const char *s, int n);//把字符串s的前n個字符連接到當前字符串結尾 string& append(const string &s);//同operator+=() string& append(const string &s, int pos, int n);//把字符串s中從pos開始的n個字符連接到當前字符串結尾 string& append(int n, char c);//在當前字符串結尾添加n個字符c

string查找和替換

int find(const string& str, int pos = 0) const; //查找str第一次出現位置,從pos開始查找 int find(const char* s, int pos = 0) const; //查找s第一次出現位置,從pos開始查找 int find(const char* s, int pos, int n) const; //從pos位置查找s的前n個字符第一次位置 int find(const char c, int pos = 0) const; //查找字符c第一次出現位置 int rfind(const string& str, int pos = npos) const;//查找str最后一次位置,從pos開始查找 int rfind(const char* s, int pos = npos) const;//查找s最后一次出現位置,從pos開始查找 int rfind(const char* s, int pos, int n) const;//從pos查找s的前n個字符最后一次位置 int rfind(const char c, int pos = 0) const; //查找字符c最后一次出現位置 string& replace(int pos, int n, const string& str); //替換從pos開始n個字符為字符串str string& replace(int pos, int n, const char* s); //替換從pos開始的n個字符為字符串s

string比較操作

/* compare函數在>時返回 1，<時返回 -1，==時返回 0。比較區分大小寫，比較時參考字典順序，排越前面的越小。大寫的A比小寫的a小。 */ int compare(const string &s) const;//與字符串s比較 int compare(const char *s) const;//與字符串s比較

string子串

string substr(int pos = 0, int n = npos) const;//返回由pos開始的n個字符組成的字符串

string插入和刪除操作

string& insert(int pos, const char* s); //插入字符串 string& insert(int pos, const string& str); //插入字符串 string& insert(int pos, int n, char c);//在指定位置插入n個字符c string& erase(int pos, int n = npos);//刪除從Pos開始的n個字符

string和c-style字符串轉換

//string 轉 char* string str = "it"; const char* cstr = str.c_str(); //char* 轉 string char* s = "it"; string str(s);

在c++中存在一個從const char*到string的隱式類型轉換，卻不存在從一個string對象到C_string的自動類型轉換。對于string類型的字符串，可以通過c_str()函數返回string對象對應的C_string.

通常，程序員在整個程序中應堅持使用string類對象，直到必須將內容轉化為char*時才將其轉換為C_string.

為了修改string字符串的內容，下標操作符[]和at都會返回字符的引用。但當字符串的內存被重新分配之后，可能發生錯誤.

string s = "abcdefg";char& a = s[2];char& b = s[3];a = '1';b = '2';cout << s << endl;cout << (int*)s.c_str() << endl;s = "pppppppppppppppppppppppp";//a = '1';//b = '2';cout << s << endl;cout << (int*)s.c_str() << endl;

2. vector容器

vector容器基本概念

vector的數據安排以及操作方式，與array非常相似，兩者的唯一差別在于空間的運用的靈活性。

Array是靜態空間，一旦配置了就不能改變，要換大一點或者小一點的空間，可以，一切瑣碎得由自己來，首先配置一塊新的空間，然后將舊空間的數據搬往新空間，再釋放原來的空間。

Vector是動態空間，隨著元素的加入，它的內部機制會自動擴充空間以容納新元素。因此vector的運用對于內存的合理利用與運用的靈活性有很大的幫助，我們再也不必害怕空間不足而一開始就要求一個大塊頭的array了。

Vector的實現技術，關鍵在于其對大小的控制以及重新配置時的數據移動效率，一旦vector舊空間滿了，如果客戶每新增一個元素，vector內部只是擴充一個元素的空間，實為不智，因為所謂的擴充空間(不論多大)，一如剛所說，是”配置新空間-數據移動-釋放舊空間”的大工程,時間成本很高，應該加入某種未雨綢繆的考慮，稍后我們便可以看到vector的空間配置策略。

vector迭代器

Vector維護一個線性空間，所以不論元素的型別如何，普通指針都可以作為vector的迭代器，因為vector迭代器所需要的操作行為，如operaroe*, operator->, operator++, operator–, operator+, operator-, operator+=, operator-=, 普通指針天生具備。

Vector支持隨機存取，而普通指針正有著這樣的能力。所以vector提供的是隨機訪問迭代器(Random Access Iterators).

根據上述描述，如果我們寫如下的代碼：

Vector<int>::iterator it1; Vector<Teacher>::iterator it2;

it1的型別其實就是Int*,it2的型別其實就是Teacher*.

#define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<vector> using namespace std;int main(){vector<int> v;for (int i = 0; i < 10;i ++){v.push_back(i);cout << v.capacity() << endl; // v.capacity()容器的容量}system("pause");return EXIT_SUCCESS; }

vector的數據結構

Vector所采用的數據結構非常簡單，線性連續空間，它以兩個迭代器_Myfirst和_Mylast分別指向配置得來的連續空間中目前已被使用的范圍，并以迭代器_Myend指向整塊連續內存空間的尾端。

為了降低空間配置時的速度成本，vector實際配置的大小可能比客戶端需求大一些，以備將來可能的擴充，這邊是容量的概念。換句話說，一個vector的容量永遠大于或等于其大小，一旦容量等于大小，便是滿載，下次再有新增元素，整個vector容器就得另覓居所。

所謂動態增加大小，并不是在原空間之后續接新空間(因為無法保證原空間之后尚有可配置的空間)，而是一塊更大的內存空間，然后將原數據拷貝新空間，并釋放原空間。因此，對vector的任何操作，一旦引起空間的重新配置，指向原vector的所有迭代器就都失效了。這是程序員容易犯的一個錯誤，務必小心。

vector常用API操作

vector構造函數

vector<T> v; //采用模板實現類實現，默認構造函數 vector(v.begin(), v.end());//將v[begin(), end())區間中的元素拷貝給本身。 vector(n, elem);//構造函數將n個elem拷貝給本身。 vector(const vector &vec);//拷貝構造函數。

//例子使用第二個構造函數我們可以... int arr[] = {2,3,4,1,9}; vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));

vector常用賦值操作

assign(beg, end);//將[beg, end)區間中的數據拷貝賦值給本身。 assign(n, elem);//將n個elem拷貝賦值給本身。 vector& operator=(const vector &vec);//重載等號操作符 swap(vec);// 將vec與本身的元素互換。

vector大小操作

size();//返回容器中元素的個數 empty();//判斷容器是否為空 resize(int num);//重新指定容器的長度為num，若容器變長，則以默認值填充新位置。如果容器變短，則末尾超出容器長度的元素被刪除。 resize(int num, elem);//重新指定容器的長度為num，若容器變長，則以elem值填充新位置。如果容器變短，則末尾超出容器長>度的元素被刪除。 capacity();//容器的容量 reserve(int len);//容器預留len個元素長度，預留位置不初始化，元素不可訪問。

vector數據存取操作

at(int idx); //返回索引idx所指的數據，如果idx越界，拋出out_of_range異常。 operator[];//返回索引idx所指的數據，越界時，運行直接報錯 front();//返回容器中第一個數據元素 back();//返回容器中最后一個數據元素

vector插入和刪除操作

insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count個元素ele. push_back(ele); //尾部插入元素ele pop_back();//刪除最后一個元素 erase(const_iterator start, const_iterator end);//刪除迭代器從start到end之間的元素 erase(const_iterator pos);//刪除迭代器指向的元素 clear();//刪除容器中所有元素

vector 小demo: 巧用swap，收縮內存空間

#define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<vector> using namespace std;int main(){vector<int> v;for (int i = 0; i < 100000;i ++){v.push_back(i);}cout << "capacity:" << v.capacity() << endl;cout << "size:" << v.size() << endl;//此時通過resize改變容器大小v.resize(10);cout << "capacity:" << v.capacity() << endl;cout << "size:" << v.size() << endl;//容量沒有改變vector<int>(v).swap(v);cout << "capacity:" << v.capacity() << endl;cout << "size:" << v.size() << endl;system("pause");return EXIT_SUCCESS; }

reserve預留空間

#define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<vector> using namespace std;int main(){vector<int> v;//預先開辟空間v.reserve(100000);int* pStart = NULL;int count = 0;for (int i = 0; i < 100000;i ++){v.push_back(i);if (pStart != &v[0]){pStart = &v[0];count++;}}cout << "count:" << count << endl;system("pause");return EXIT_SUCCESS; }

3. deque容器

deque容器基本概念

Vector容器是單向開口的連續內存空間，deque則是一種雙向開口的連續線性空間。

所謂的雙向開口，意思是可以在頭尾兩端分別做元素的插入和刪除操作，當然，vector容器也可以在頭尾兩端插入元素，但是在其頭部操作效率奇差，無法被接受。

Deque容器和vector容器最大的差異，一在于deque允許使用常數項時間對頭端進行元素的插入和刪除操作。二在于deque沒有容量的概念，因為它是動態的以分段連續空間組合而成，隨時可以增加一段新的空間并鏈接起來，換句話說，像vector那樣，”舊空間不足而重新配置一塊更大空間，然后復制元素，再釋放舊空間”這樣的事情在deque身上是不會發生的。也因此，deque沒有必須要提供所謂的空間保留(reserve)功能.

雖然deque容器也提供了Random Access Iterator,但是它的迭代器并不是普通的指針，其復雜度和vector不是一個量級，這當然影響各個運算的層面。因此，除非有必要，我們應該盡可能的使用vector，而不是deque。對deque進行的排序操作，為了最高效率，可將deque先完整的復制到一個vector中，對vector容器進行排序，再復制回deque.

deque容器實現原理

Deque容器是連續的空間，至少邏輯上看來如此，連續現行空間總是令我們聯想到array和vector,array無法成長，vector雖可成長，卻只能向尾端成長，而且其成長其實是一個假象，事實上(1) 申請更大空間 (2)原數據復制新空間 (3)釋放原空間三步驟，如果不是vector每次配置新的空間時都留有余裕，其成長假象所帶來的代價是非常昂貴的。

Deque是由一段一段的定量的連續空間構成。一旦有必要在deque前端或者尾端增加新的空間，便配置一段連續定量的空間，串接在deque的頭端或者尾端。Deque最大的工作就是維護這些分段連續的內存空間的整體性的假象，并提供隨機存取的接口，避開了重新配置空間，復制，釋放的輪回，代價就是復雜的迭代器架構。

既然deque是分段連續內存空間，那么就必須有中央控制，維持整體連續的假象，數據結構的設計及迭代器的前進后退操作頗為繁瑣。Deque代碼的實現遠比vector或list都多得多。

Deque采取一塊所謂的map(注意，不是STL的map容器)作為主控，這里所謂的map是一小塊連續的內存空間，其中每一個元素(此處成為一個結點)都是一個指針，指向另一段連續性內存空間，稱作緩沖區。緩沖區才是deque的存儲空間的主體。

deque常用API

deque構造函數

deque<T> deqT;//默認構造形式 deque(beg, end);//構造函數將[beg, end)區間中的元素拷貝給本身。 deque(n, elem);//構造函數將n個elem拷貝給本身。 deque(const deque &deq);//拷貝構造函數。

deque賦值操作

assign(beg, end);//將[beg, end)區間中的數據拷貝賦值給本身。 assign(n, elem);//將n個elem拷貝賦值給本身。 deque& operator=(const deque &deq); //重載等號操作符 swap(deq);// 將deq與本身的元素互換

deque大小操作

deque.size();//返回容器中元素的個數 deque.empty();//判斷容器是否為空 deque.resize(num);//重新指定容器的長度為num,若容器變長，則以默認值填充新位置。如果容器變短，則末尾超出容器長度的元素被刪除。 deque.resize(num, elem); //重新指定容器的長度為num,若容器變長，則以elem值填充新位置,如果容器變短，則末尾超出容器長度的元素被刪除。

deque雙端插入和刪除操作

push_back(elem);//在容器尾部添加一個數據 push_front(elem);//在容器頭部插入一個數據 pop_back();//刪除容器最后一個數據 pop_front();//刪除容器第一個數據

deque數據存取

at(idx);//返回索引idx所指的數據，如果idx越界，拋出out_of_range。 operator[];//返回索引idx所指的數據，如果idx越界，不拋出異常，直接出錯。 front();//返回第一個數據。 back();//返回最后一個數據

deque插入操作

insert(pos,elem);//在pos位置插入一個elem元素的拷貝，返回新數據的位置。 insert(pos,n,elem);//在pos位置插入n個elem數據，無返回值。 insert(pos,beg,end);//在pos位置插入[beg,end)區間的數據，無返回值。

deque刪除操作

clear();//移除容器的所有數據 erase(beg,end);//刪除[beg,end)區間的數據，返回下一個數據的位置。 erase(pos);//刪除pos位置的數據，返回下一個數據的位置。

4. stack容器

stack容器基本概念

stack是一種先進后出(First In Last Out,FILO)的數據結構，它只有一個出口，形式如圖所示。stack容器允許新增元素，移除元素，取得棧頂元素，但是除了最頂端外，沒有任何其他方法可以存取stack的其他元素。換言之，stack不允許有遍歷行為。
有元素推入棧的操作稱為:push,將元素推出stack的操作稱為pop.

stack沒有迭代器

Stack所有元素的進出都必須符合”先進后出”的條件，只有stack頂端的元素，才有機會被外界取用。Stack不提供遍歷功能，也不提供迭代器。

stack常用API

stack構造函數

stack<T> stkT;//stack采用模板類實現， stack對象的默認構造形式： stack(const stack &stk);//拷貝構造函數

stack賦值操作

stack& operator=(const stack &stk);//重載等號操作符

stack數據存取操作

push(elem);//向棧頂添加元素 pop();//從棧頂移除第一個元素 top();//返回棧頂元素

stack大小操作

empty();//判斷堆棧是否為空 size();//返回堆棧的大小

5. queue容器

queue容器基本概念

Queue是一種先進先出(First In First Out,FIFO)的數據結構，它有兩個出口，queue容器允許從一端新增元素，從另一端移除元素。

queue沒有迭代器

Queue所有元素的進出都必須符合”先進先出”的條件，只有queue的頂端元素，才有機會被外界取用。Queue不提供遍歷功能，也不提供迭代器。

queue常用API

queue構造函數

queue<T> queT;//queue采用模板類實現，queue對象的默認構造形式： queue(const queue &que);//拷貝構造函數

queue存取、插入和刪除操作

push(elem);//往隊尾添加元素 pop();//從隊頭移除第一個元素 back();//返回最后一個元素 front();//返回第一個元素

queue賦值操作

queue& operator=(const queue &que);//重載等號操作符

queue大小操作

empty();//判斷隊列是否為空 size();//返回隊列的大小

6. list容器

list容器基本概念
鏈表是一種物理存儲單元上非連續、非順序的存儲結構，數據元素的邏輯順序是通過鏈表中的指針鏈接次序實現的。

鏈表由一系列結點（鏈表中每一個元素稱為結點）組成，結點可以在運行時動態生成。每個結點包括兩個部分：一個是存儲數據元素的數據域，另一個是存儲下一個結點地址的指針域。

相較于vector的連續線性空間，list就顯得負責許多，它的好處是每次插入或者刪除一個元素，就是配置或者釋放一個元素的空間。因此，list對于空間的運用有絕對的精準，一點也不浪費。而且，對于任何位置的元素插入或元素的移除，list永遠是常數時間。

List和vector是兩個最常被使用的容器。

List容器是一個雙向鏈表。

采用動態存儲分配，不會造成內存浪費和溢出
鏈表執行插入和刪除操作十分方便，修改指針即可，不需要移動大量元素
鏈表靈活，但是空間和時間額外耗費較大

list容器的迭代器

List容器不能像vector一樣以普通指針作為迭代器，因為其節點不能保證在同一塊連續的內存空間上。

List迭代器必須有能力指向list的節點，并有能力進行正確的遞增、遞減、取值、成員存取操作。所謂”list正確的遞增，遞減、取值、成員取用”是指，遞增時指向下一個節點，遞減時指向上一個節點，取值時取的是節點的數據值，成員取用時取的是節點的成員。

由于list是一個雙向鏈表，迭代器必須能夠具備前移、后移的能力，所以list容器提供的是Bidirectional Iterators.

List有一個重要的性質，插入操作和刪除操作都不會造成原有list迭代器的失效。這在vector是不成立的，因為vector的插入操作可能造成記憶體重新配置，導致原有的迭代器全部失效，甚至List元素的刪除，也只有被刪除的那個元素的迭代器失效，其他迭代器不受任何影響。

list容器的數據結構

list容器不僅是一個雙向鏈表，而且還是一個循環的雙向鏈表。

#define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<list> using namespace std;int main(){list<int> myList;for (int i = 0; i < 10; i ++){myList.push_back(i);}list<int>::_Nodeptr node = myList._Myhead->_Next;for (int i = 0; i < myList._Mysize * 2;i++){cout << "Node:" << node->_Myval << endl;node = node->_Next;if (node == myList._Myhead){node = node->_Next;}}system("pause");return EXIT_SUCCESS; }

list常用API

list構造函數

list<T> lstT;//list采用采用模板類實現,對象的默認構造形式： list(beg,end);//構造函數將[beg, end)區間中的元素拷貝給本身。 list(n,elem);//構造函數將n個elem拷貝給本身。 list(const list &lst);//拷貝構造函數。

list數據元素插入和刪除操作

push_back(elem);//在容器尾部加入一個元素 pop_back();//刪除容器中最后一個元素 push_front(elem);//在容器開頭插入一個元素 pop_front();//從容器開頭移除第一個元素 insert(pos,elem);//在pos位置插elem元素的拷貝，返回新數據的位置。 insert(pos,n,elem);//在pos位置插入n個elem數據，無返回值。 insert(pos,beg,end);//在pos位置插入[beg,end)區間的數據，無返回值。 clear();//移除容器的所有數據 erase(beg,end);//刪除[beg,end)區間的數據，返回下一個數據的位置。 erase(pos);//刪除pos位置的數據，返回下一個數據的位置。 remove(elem);//刪除容器中所有與elem值匹配的元素。

list大小操作

size();//返回容器中元素的個數 empty();//判斷容器是否為空 resize(num);//重新指定容器的長度為num，若容器變長，則以默認值填充新位置。如果容器變短，則末尾超出容器長度的元素被刪除。 resize(num, elem);//重新指定容器的長度為num，若容器變長，則以elem值填充新位置。如果容器變短，則末尾超出容器長度的元素被刪除。

list賦值操作

assign(beg, end);//將[beg, end)區間中的數據拷貝賦值給本身。 assign(n, elem);//將n個elem拷貝賦值給本身。 list& operator=(const list &lst);//重載等號操作符 swap(lst);//將lst與本身的元素互換。

list數據的存取

front();//返回第一個元素。 back();//返回最后一個元素。

list反轉排序

reverse();//反轉鏈表，比如lst包含1,3,5元素，運行此方法后，lst就包含5,3,1元素。 sort(); //list排序

7. set/multiset容器

set容器基本概念

Set的特性是。所有元素都會根據元素的鍵值自動被排序。Set的元素不像map那樣可以同時擁有實值和鍵值，set的元素即是鍵值又是實值。Set不允許兩個元素有相同的鍵值。

我們不可以通過set的迭代器改變set元素的值，因為set元素值就是其鍵值，關系到set元素的排序規則。如果任意改變set元素值，會嚴重破壞set組織。換句話說，set的iterator是一種const_iterator.

set擁有和list某些相同的性質，當對容器中的元素進行插入操作或者刪除操作的時候，操作之前所有的迭代器，在操作完成之后依然有效，被刪除的那個元素的迭代器必然是一個例外。

multiset容器基本概念

multiset特性及用法和set完全相同，唯一的差別在于它允許鍵值重復。set和multiset的底層實現是紅黑樹.

set常用API

set構造函數

set<T> st;//set默認構造函數： mulitset<T> mst; //multiset默認構造函數: set(const set &st);//拷貝構造函數

set賦值操作

set& operator=(const set &st);//重載等號操作符 swap(st);//交換兩個集合容器

set大小操作

size();//返回容器中元素的數目 empty();//判斷容器是否為空

set插入和刪除操作

insert(elem);//在容器中插入元素。 clear();//清除所有元素 erase(pos);//刪除pos迭代器所指的元素，返回下一個元素的迭代器。 erase(beg, end);//刪除區間[beg,end)的所有元素，返回下一個元素的迭代器。 erase(elem);//刪除容器中值為elem的元素。

set查找操作

find(key);//查找鍵key是否存在,若存在，返回該鍵的元素的迭代器；若不存在，返回set.end(); count(key);//查找鍵key的元素個數 lower_bound(keyElem);//返回第一個key>=keyElem元素的迭代器。 upper_bound(keyElem);//返回第一個key>keyElem元素的迭代器。 equal_range(keyElem);//返回容器中key與keyElem相等的上下限的兩個迭代器。

set的返回值指定set排序規則舉例:

//插入操作返回值 void test01(){set<int> s;pair<set<int>::iterator,bool> ret = s.insert(10);if (ret.second){cout << "插入成功:" << *ret.first << endl;}else{cout << "插入失敗:" << *ret.first << endl;}ret = s.insert(10);if(ret.second){cout << "插入成功:" << *ret.first << endl;}else{cout << "插入失敗:" << *ret.first << endl;}}struct MyCompare02{bool operator()(int v1,int v2){return v1 > v2;} };//set從大到小 void test02(){srand((unsigned int)time(NULL));//我們發現set容器的第二個模板參數可以設置排序規則，默認規則是less<_Kty>set<int, MyCompare02> s;for (int i = 0; i < 10;i++){s.insert(rand() % 100);}for (set<int, MyCompare02>::iterator it = s.begin(); it != s.end(); it ++){cout << *it << " ";}cout << endl; }//set容器中存放對象 class Person{ public:Person(string name,int age){this->mName = name;this->mAge = age;} public:string mName;int mAge; };struct MyCompare03{bool operator()(const Person& p1,const Person& p2){return p1.mAge > p2.mAge;} };void test03(){set<Person, MyCompare03> s;Person p1("aaa", 20);Person p2("bbb", 30);Person p3("ccc", 40);Person p4("ddd", 50);s.insert(p1);s.insert(p2);s.insert(p3);s.insert(p4);for (set<Person, MyCompare03>::iterator it = s.begin(); it != s.end(); it++){cout << "Name:" << it->mName << " Age:" << it->mAge << endl;}}

對組(pair)

對組(pair)將一對值組合成一個值，這一對值可以具有不同的數據類型，兩個值可以分別用pair的兩個公有屬性first和second訪問。
類模板：template <class T1, class T2> struct pair.
創建對組:

//第一種方法創建一個對組 pair<string, int> pair1(string("name"), 20); cout << pair1.first << endl; //訪問pair第一個值 cout << pair1.second << endl;//訪問pair第二個值 //第二種 pair<string, int> pair2 = make_pair("name", 30); cout << pair2.first << endl; cout << pair2.second << endl; //pair=賦值 pair<string, int> pair3 = pair2; cout << pair3.first << endl; cout << pair3.second << endl;

8. map/multimap容器

map/multimap基本概念

Map的特性是，所有元素都會根據元素的鍵值自動排序。

Map所有的元素都是pair,同時擁有實值和鍵值，pair的第一元素被視為鍵值，第二元素被視為實值，map不允許兩個元素有相同的鍵值。

我們不可以通過map的迭代器改變map的鍵值, 因為map的鍵值關系到map元素的排列規則，任意改變map鍵值將會嚴重破壞map組織。如果想要修改元素的實值，那么是可以的。

Map和list擁有相同的某些性質，當對它的容器元素進行新增操作或者刪除操作時，操作之前的所有迭代器，在操作完成之后依然有效，當然被刪除的那個元素的迭代器必然是個例外。

Multimap和map的操作類似，唯一區別multimap鍵值可重復。

Map和multimap都是以紅黑樹為底層實現機制。

map/multimap常用API

map構造函數

map<T1, T2> mapTT;//map默認構造函數: map(const map &mp);//拷貝構造函數

map賦值操作

map& operator=(const map &mp);//重載等號操作符 swap(mp);//交換兩個集合容器

map大小操作

size();//返回容器中元素的數目 empty();//判斷容器是否為空

map插入數據元素操作

map.insert(...); //往容器插入元素，返回pair<iterator,bool> map<int, string> mapStu; // 第一種通過pair的方式插入對象 mapStu.insert(pair<int, string>(3, "小張")); // 第二種通過pair的方式插入對象 mapStu.inset(make_pair(-1, "校長")); // 第三種通過value_type的方式插入對象 mapStu.insert(map<int, string>::value_type(1, "小李")); // 第四種通過數組的方式插入值 mapStu[3] = "小劉"; mapStu[5] = "小王";

map刪除操作

clear();//刪除所有元素 erase(pos);//刪除pos迭代器所指的元素，返回下一個元素的迭代器。 erase(beg,end);//刪除區間[beg,end)的所有元素，返回下一個元素的迭代器。 erase(keyElem);//刪除容器中key為keyElem的對組。

map查找操作

find(key);//查找鍵key是否存在,若存在，返回該鍵的元素的迭代器；/若不存在，返回map.end(); count(keyElem);//返回容器中key為keyElem的對組個數。對map來說，要么是0，要么是1。對multimap來說，值可能大于1。 lower_bound(keyElem);//返回第一個key>=keyElem元素的迭代器。 upper_bound(keyElem);//返回第一個key>keyElem元素的迭代器。 equal_range(keyElem);//返回容器中key與keyElem相等的上下限的兩個迭代器。

multimap案例

//公司今天招聘了5個員工，5名員工進入公司之后，需要指派員工在那個部門工作 //人員信息有: 姓名年齡電話工資等組成 //通過Multimap進行信息的插入保存顯示 //分部門顯示員工信息顯示全部員工信息#define _CRT_SECURE_NO_WARNINGS#include<iostream> #include<map> #include<string> #include<vector> using namespace std;//multimap 案例 //公司今天招聘了 5 個員工，5 名員工進入公司之后，需要指派員工在那個部門工作 //人員信息有: 姓名年齡電話工資等組成 //通過 Multimap 進行信息的插入保存顯示 //分部門顯示員工信息顯示全部員工信息#define SALE_DEPATMENT 1 //銷售部門 #define DEVELOP_DEPATMENT 2 //研發部門 #define FINACIAL_DEPATMENT 3 //財務部門 #define ALL_DEPATMENT 4 //所有部門//員工類 class person{ public:string name; //員工姓名int age; //員工年齡double salary; //員工工資string tele; //員工電話 };//創建5個員工 void CreatePerson(vector<person>& vlist){string seed = "ABCDE";for (int i = 0; i < 5; i++){person p;p.name = "員工";p.name += seed[i];p.age = rand() % 30 + 20;p.salary = rand() % 20000 + 10000;p.tele = "010-8888888";vlist.push_back(p);}}//5名員工分配到不同的部門 void PersonByGroup(vector<person>& vlist, multimap<int, person>& plist){int operate = -1; //用戶的操作for (vector<person>::iterator it = vlist.begin(); it != vlist.end(); it++){cout << "當前員工信息:" << endl;cout << "姓名：" << it->name << " 年齡:" << it->age << " 工資:" << it->salary << " 電話：" << it->tele << endl;cout << "請對該員工進行部門分配(1 銷售部門, 2 研發部門, 3 財務部門):" << endl;scanf("%d", &operate);while (true){if (operate == SALE_DEPATMENT){ //將該員工加入到銷售部門plist.insert(make_pair(SALE_DEPATMENT, *it));break;}else if (operate == DEVELOP_DEPATMENT){plist.insert(make_pair(DEVELOP_DEPATMENT, *it));break;}else if (operate == FINACIAL_DEPATMENT){plist.insert(make_pair(FINACIAL_DEPATMENT, *it));break;}else{cout << "您的輸入有誤，請重新輸入(1 銷售部門, 2 研發部門, 3 財務部門):" << endl;scanf("%d", &operate);}}}cout << "員工部門分配完畢!" << endl;cout << "***********************************************************" << endl;}//打印員工信息 void printList(multimap<int, person>& plist, int myoperate){if (myoperate == ALL_DEPATMENT){for (multimap<int, person>::iterator it = plist.begin(); it != plist.end(); it++){cout << "姓名：" << it->second.name << " 年齡:" << it->second.age << " 工資:" << it->second.salary << " 電話：" << it->second.tele << endl;}return;}multimap<int, person>::iterator it = plist.find(myoperate);int depatCount = plist.count(myoperate);int num = 0;if (it != plist.end()){while (it != plist.end() && num < depatCount){cout << "姓名：" << it->second.name << " 年齡:" << it->second.age << " 工資:" << it->second.salary << " 電話：" << it->second.tele << endl;it++;num++;}} }//根據用戶操作顯示不同部門的人員列表 void ShowPersonList(multimap<int, person>& plist, int myoperate){switch (myoperate){case SALE_DEPATMENT:printList(plist, SALE_DEPATMENT);break;case DEVELOP_DEPATMENT:printList(plist, DEVELOP_DEPATMENT);break;case FINACIAL_DEPATMENT:printList(plist, FINACIAL_DEPATMENT);break;case ALL_DEPATMENT:printList(plist, ALL_DEPATMENT);break;} }//用戶操作菜單 void PersonMenue(multimap<int, person>& plist){int flag = -1;int isexit = 0;while (true){cout << "請輸入您的操作((1 銷售部門, 2 研發部門, 3 財務部門, 4 所有部門, 0退出)：" << endl;scanf("%d", &flag);switch (flag){case SALE_DEPATMENT:ShowPersonList(plist, SALE_DEPATMENT);break;case DEVELOP_DEPATMENT:ShowPersonList(plist, DEVELOP_DEPATMENT);break;case FINACIAL_DEPATMENT:ShowPersonList(plist, FINACIAL_DEPATMENT);break;case ALL_DEPATMENT:ShowPersonList(plist, ALL_DEPATMENT);break;case 0:isexit = 1;break;default:cout << "您的輸入有誤，請重新輸入!" << endl;break;}if (isexit == 1){break;}}}int main(){vector<person> vlist; //創建的5個員工未分組multimap<int, person> plist; //保存分組后員工信息//創建5個員工CreatePerson(vlist);//5名員工分配到不同的部門PersonByGroup(vlist, plist);//根據用戶輸入顯示不同部門員工信息列表或者顯示全部員工的信息列表PersonMenue(plist);system("pause");return EXIT_SUCCESS; }

STL容器使用時機

.vectordequelistsetmultisetmapmultimap

典型內存結構	單端數組	雙端數組	雙向鏈表	二叉樹	二叉樹	二叉樹	二叉樹
可隨機存取	是	是	否	否	否	對key而言：不是	否
元素搜尋速度	慢	慢	非常慢	快	快	對key而言：快	對key而言：快
元素安插移除	尾端	頭尾兩端	任何位置	-	-	-	-

vector的使用場景：比如軟件歷史操作記錄的存儲，我們經常要查看歷史記錄，比如上一次的記錄，上上次的記錄，但卻不會去刪除記錄，因為記錄是事實的描述。

deque的使用場景：比如排隊購票系統，對排隊者的存儲可以采用deque，支持頭端的快速移除，尾端的快速添加。如果采用vector，則頭端移除時，會移動大量的數據，速度慢。

vector與deque的比較：
一：vector.at()比deque.at()效率高，比如vector.at(0)是固定的，deque的開始位置卻是不固定的。
二：如果有大量釋放操作的話，vector花的時間更少，這跟二者的內部實現有關。
三：deque支持頭部的快速插入與快速移除，這是deque的優點。

list的使用場景：比如公交車乘客的存儲，隨時可能有乘客下車，支持頻繁的不確實位置元素的移除插入。

set的使用場景：比如對手機游戲的個人得分記錄的存儲，存儲要求從高分到低分的順序排列。

map的使用場景：比如按ID號存儲十萬個用戶，想要快速要通過ID查找對應的用戶。二叉樹的查找效率，這時就體現出來了。如果是vector容器，最壞的情況下可能要遍歷完整個容器才能找到該用戶。

常用算法

1. 函數對象

重載函數調用操作符的類，其對象常稱為函數對象（function object），即它們是行為類似函數的對象，也叫仿函數(functor),其實就是重載“()”操作符，使得類對象可以像函數那樣調用。

注意:

函數對象(仿函數)是一個類，不是一個函數。

函數對象(仿函數)重載了”() ”操作符使得它可以像函數一樣調用。

分類:假定某個類有一個重載的operator()，而且重載的operator()要求獲取一個參數，我們就將這個類稱為“一元仿函數”（unary functor）；相反，如果重載的operator()要求獲取兩個參數，就將這個類稱為“二元仿函數”（binary functor）。

函數對象的作用:
STL提供的算法往往都有兩個版本，其中一個版本表現出最常用的某種運算，另一版本則允許用戶通過template參數的形式來指定所要采取的策略。

//函數對象是重載了函數調用符號的類 class MyPrint { public:MyPrint(){m_Num = 0;}int m_Num;public:void operator() (int num){cout << num << endl;m_Num++;} };//函數對象 //重載了()操作符的類實例化的對象，可以像普通函數那樣調用,可以有參數，可以有返回值 void test01() {MyPrint myPrint;myPrint(20);} // 函數對象超出了普通函數的概念，可以保存函數的調用狀態 void test02() {MyPrint myPrint;myPrint(20);myPrint(20);myPrint(20);cout << myPrint.m_Num << endl; }void doBusiness(MyPrint print,int num) {print(num); }//函數對象作為參數 void test03() {//參數1：匿名函數對象doBusiness(MyPrint(),30); }

總結：
1、函數對象通常不定義構造函數和析構函數，所以在構造和析構時不會發生任何問題，避免了函數調用的運行時問題。
2、函數對象超出普通函數的概念，函數對象可以有自己的狀態
3、函數對象可內聯編譯，性能好。用函數指針幾乎不可能
4、模版函數對象使函數對象具有通用性，這也是它的優勢之一

2. 謂詞

謂詞是指普通函數或重載的operator()返回值是bool類型的函數對象(仿函數)。如果operator接受一個參數，那么叫做一元謂詞,如果接受兩個參數，那么叫做二元謂詞，謂詞可作為一個判斷式。

class GreaterThenFive { public:bool operator()(int num){return num > 5;}}; //一元謂詞 void test01() {vector<int> v;for (int i = 0; i < 10;i ++){v.push_back(i);}vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterThenFive());if (it == v.end()){cout << "沒有找到" << endl;}else{cout << "找到了: " << *it << endl;} }//二元謂詞 class MyCompare { public:bool operator()(int num1, int num2){return num1 > num2;} };void test02() {vector<int> v;v.push_back(10);v.push_back(40);v.push_back(20);v.push_back(90);v.push_back(60);//默認從小到大sort(v.begin(), v.end());for (vector<int>::iterator it = v.begin(); it != v.end();it++){cout << *it << " ";}cout << endl;cout << "----------------------------" << endl;//使用函數對象改變算法策略，排序從大到小sort(v.begin(), v.end(),MyCompare());for (vector<int>::iterator it = v.begin(); it != v.end(); it++){cout << *it << " ";}cout << endl; }

3.內建函數對象

STL內建了一些函數對象。分為:算數類函數對象,關系運算類函數對象，邏輯運算類仿函數。這些仿函數所產生的對象，用法和一般函數完全相同，當然我們還可以產生無名的臨時對象來履行函數功能。使用內建函數對象，需要引入頭文件

#include<functional>。

6個算數類函數對象,除了negate是一元運算，其他都是二元運算。

template<class T> T plus<T>//加法仿函數 template<class T> T minus<T>//減法仿函數 template<class T> T multiplies<T>//乘法仿函數 template<class T> T divides<T>//除法仿函數 template<class T> T modulus<T>//取模仿函數 template<class T> T negate<T>//取反仿函數

6個關系運算類函數對象,每一種都是二元運算。

template<class T> bool equal_to<T>//等于 template<class T> bool not_equal_to<T>//不等于 template<class T> bool greater<T>//大于 template<class T> bool greater_equal<T>//大于等于 template<class T> bool less<T>//小于 template<class T> bool less_equal<T>//小于等于

邏輯運算類運算函數,not為一元運算，其余為二元運算。

template<class T> bool logical_and<T>//邏輯與 template<class T> bool logical_or<T>//邏輯或 template<class T> bool logical_not<T>//邏輯非

內建函數對象舉例:

//取反仿函數 void test01() {negate<int> n;cout << n(50) << endl; }//加法仿函數 void test02() {plus<int> p;cout << p(10, 20) << endl; }//大于仿函數 void test03() {vector<int> v;srand((unsigned int)time(NULL));for (int i = 0; i < 10; i++){v.push_back(rand() % 100);}for (vector<int>::iterator it = v.begin(); it != v.end(); it++){cout << *it << " ";}cout << endl;sort(v.begin(), v.end(), greater<int>());for (vector<int>::iterator it = v.begin(); it != v.end(); it++){cout << *it << " ";}cout << endl;}

4. 函數對象適配器

//函數適配器bind1st bind2nd //現在我有這個需求在遍歷容器的時候，我希望將容器中的值全部加上100之后顯示出來，怎么做？ //我們直接給函數對象綁定參數編譯階段就會報錯 //for_each(v.begin(), v.end(), bind2nd(myprint(),100)); //如果我們想使用綁定適配器,需要我們自己的函數對象繼承binary_function 或者 unary_function //根據我們函數對象是一元函數對象還是二元函數對象 class MyPrint :public binary_function<int,int,void> { public:void operator()(int v1,int v2) const{cout << "v1 = : " << v1 << " v2 = :" <<v2 << " v1+v2 = :" << (v1 + v2) << endl; } }; //1、函數適配器 void test01() {vector<int>v;for (int i = 0; i < 10; i++){v.push_back(i);}cout << "請輸入起始值：" << endl;int x;cin >> x;for_each(v.begin(), v.end(), bind1st(MyPrint(), x));//for_each(v.begin(), v.end(), bind2nd( MyPrint(),x )); } //總結： bind1st和bind2nd區別? //bind1st ：將參數綁定為函數對象的第一個參數 //bind2nd ：將參數綁定為函數對象的第二個參數 //bind1st bind2nd將二元函數對象轉為一元函數對象class GreaterThenFive:public unary_function<int,bool> { public:bool operator ()(int v) const{return v > 5;} };//2、取反適配器 void test02() {vector <int> v;for (int i = 0; i < 10;i++){v.push_back(i);}// vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterThenFive()); //返回第一個大于5的迭代器 // vector<int>::iterator it = find_if(v.begin(), v.end(), not1(GreaterThenFive())); //返回第一個小于5迭代器//自定義輸入vector<int>::iterator it = find_if(v.begin(), v.end(), not1 ( bind2nd(greater<int>(),5)));if (it == v.end()){cout << "沒找到" << endl;}else{cout << "找到" << *it << endl;}//排序二元函數對象sort(v.begin(), v.end(), not2(less<int>()));for_each(v.begin(), v.end(), [](int val){cout << val << " "; });} //not1 對一元函數對象取反 //not2 對二元函數對象取反void MyPrint03(int v,int v2) {cout << v + v2<< " "; }//3、函數指針適配器 ptr_fun void test03() {vector <int> v;for (int i = 0; i < 10; i++){v.push_back(i);}// ptr_fun( )把一個普通的函數指針適配成函數對象for_each(v.begin(), v.end(), bind2nd( ptr_fun( MyPrint03 ), 100)); }//4、成員函數適配器 class Person { public:Person(string name, int age){m_Name = name;m_Age = age;}//打印函數void ShowPerson(){cout << "成員函數:" << "Name:" << m_Name << " Age:" << m_Age << endl;}void Plus100(){m_Age += 100;} public:string m_Name;int m_Age; };void MyPrint04(Person &p) {cout << "姓名：" << p.m_Name << " 年齡：" << p.m_Age << endl;};void test04() {vector <Person>v;Person p1("aaa", 10);Person p2("bbb", 20);Person p3("ccc", 30);Person p4("ddd", 40);v.push_back(p1);v.push_back(p2);v.push_back(p3);v.push_back(p4);//for_each(v.begin(), v.end(), MyPrint04);//利用 mem_fun_ref 將Person內部成員函數適配for_each(v.begin(), v.end(), mem_fun_ref(&Person::ShowPerson)); // for_each(v.begin(), v.end(), mem_fun_ref(&Person::Plus100)); // for_each(v.begin(), v.end(), mem_fun_ref(&Person::ShowPerson)); }void test05(){vector<Person*> v1;//創建數據Person p1("aaa", 10);Person p2("bbb", 20);Person p3("ccc", 30);Person p4("ddd", 40);v1.push_back(&p1);v1.push_back(&p2);v1.push_back(&p3);v1.push_back(&p4);for_each(v1.begin(), v1.end(), mem_fun(&Person::ShowPerson)); }//如果容器存放的是對象指針，那么用mem_fun //如果容器中存放的是對象實體，那么用mem_fun_ref

算法概述

算法主要是由頭文件<algorithm><functional> <numeric>組成。
<algorithm>是所有STL頭文件中最大的一個,其中常用的功能涉及到比較，交換，查找,遍歷，復制，修改，反轉，排序，合并等…
<numeric>體積很小，只包括在幾個序列容器上進行的簡單運算的模板函數.
<functional> 定義了一些模板類,用以聲明函數對象。

1. 常用遍歷算法

/*遍歷算法遍歷容器元素@param beg 開始迭代器@param end 結束迭代器@param _callback 函數回調或者函數對象@return 函數對象 */ for_each(iterator beg, iterator end, _callback); /*transform算法將指定容器區間元素搬運到另一容器中注意 : transform 不會給目標容器分配內存，所以需要我們提前分配好內存@param beg1 源容器開始迭代器@param end1 源容器結束迭代器@param beg2 目標容器開始迭代器@param _cakkback 回調函數或者函數對象@return 返回目標容器迭代器 */ transform(iterator beg1, iterator end1, iterator beg2, _callbakc)for_each: /*template<class _InIt,class _Fn1> inline void for_each(_InIt _First, _InIt _Last, _Fn1 _Func) {for (; _First != _Last; ++_First)_Func(*_First); }*///普通函數 void print01(int val){cout << val << " "; } //函數對象 struct print001{void operator()(int val){cout << val << " ";} };//for_each算法基本用法 void test01(){vector<int> v;for (int i = 0; i < 10;i++){v.push_back(i);}//遍歷算法for_each(v.begin(), v.end(), print01);cout << endl;for_each(v.begin(), v.end(), print001());cout << endl;}struct print02{print02(){mCount = 0;}void operator()(int val){cout << val << " ";mCount++;}int mCount; };//for_each返回值 void test02(){vector<int> v;for (int i = 0; i < 10; i++){v.push_back(i);}print02 p = for_each(v.begin(), v.end(), print02());cout << endl;cout << p.mCount << endl; }struct print03 : public binary_function<int, int, void>{void operator()(int val,int bindParam) const{cout << val + bindParam << " ";} };//for_each綁定參數輸出 void test03(){vector<int> v;for (int i = 0; i < 10; i++){v.push_back(i);}for_each(v.begin(), v.end(), bind2nd(print03(),100)); }transform: //transform 將一個容器中的值搬運到另一個容器中 /*template<class _InIt, class _OutIt, class _Fn1> inline _OutIt _Transform(_InIt _First, _InIt _Last,_OutIt _Dest, _Fn1 _Func){ for (; _First != _Last; ++_First, ++_Dest)*_Dest = _Func(*_First);return (_Dest);}template<class _InIt1,class _InIt2,class _OutIt,class _Fn2> inline_OutIt _Transform(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _OutIt _Dest, _Fn2 _Func){ for (; _First1 != _Last1; ++_First1, ++_First2, ++_Dest)*_Dest = _Func(*_First1, *_First2);return (_Dest);} */struct transformTest01{int operator()(int val){return val + 100;} }; struct print01{void operator()(int val){cout << val << " ";} }; void test01(){vector<int> vSource;for (int i = 0; i < 10;i ++){vSource.push_back(i + 1);}//目標容器vector<int> vTarget;//給vTarget開辟空間vTarget.resize(vSource.size());//將vSource中的元素搬運到vTargetvector<int>::iterator it = transform(vSource.begin(), vSource.end(), vTarget.begin(), transformTest01());//打印for_each(vTarget.begin(), vTarget.end(), print01()); cout << endl;}//將容器1和容器2中的元素相加放入到第三個容器中 struct transformTest02{int operator()(int v1,int v2){return v1 + v2;} }; void test02(){vector<int> vSource1;vector<int> vSource2;for (int i = 0; i < 10; i++){vSource1.push_back(i + 1); }//目標容器vector<int> vTarget;//給vTarget開辟空間vTarget.resize(vSource1.size());transform(vSource1.begin(), vSource1.end(), vSource2.begin(),vTarget.begin(), transformTest02());//打印for_each(vTarget.begin(), vTarget.end(), print01()); cout << endl; }

2. 常用查找算法

/*find算法查找元素@param beg 容器開始迭代器@param end 容器結束迭代器@param value 查找的元素@return 返回查找元素的位置 */ find(iterator beg, iterator end, value) /*find_if算法條件查找@param beg 容器開始迭代器@param end 容器結束迭代器@param callback 回調函數或者謂詞(返回bool類型的函數對象)@return bool 查找返回true 否則false */ find_if(iterator beg, iterator end, _callback);/*adjacent_find算法查找相鄰重復元素@param beg 容器開始迭代器@param end 容器結束迭代器@param _callback 回調函數或者謂詞(返回bool類型的函數對象)@return 返回相鄰元素的第一個位置的迭代器 */ adjacent_find(iterator beg, iterator end, _callback); /*binary_search算法二分查找法注意: 在無序序列中不可用@param beg 容器開始迭代器@param end 容器結束迭代器@param value 查找的元素@return bool 查找返回true 否則false */ bool binary_search(iterator beg, iterator end, value); /*count算法統計元素出現次數@param beg 容器開始迭代器@param end 容器結束迭代器@param value回調函數或者謂詞(返回bool類型的函數對象)@return int返回元素個數 */ count(iterator beg, iterator end, value); /*count算法統計元素出現次數@param beg 容器開始迭代器@param end 容器結束迭代器@param callback 回調函數或者謂詞(返回bool類型的函數對象)@return int返回元素個數 */ count_if(iterator beg, iterator end, _callback);

3. 常用排序算法

/*merge算法容器元素合并，并存儲到另一容器中@param beg1 容器1開始迭代器@param end1 容器1結束迭代器@param beg2 容器2開始迭代器@param end2 容器2結束迭代器@param dest 目標容器開始迭代器 */ merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest) /*sort算法容器元素排序注意:兩個容器必須是有序的@param beg 容器1開始迭代器@param end 容器1結束迭代器@param _callback 回調函數或者謂詞(返回bool類型的函數對象) */ sort(iterator beg, iterator end, _callback) /*sort算法對指定范圍內的元素隨機調整次序@param beg 容器開始迭代器@param end 容器結束迭代器 */ random_shuffle(iterator beg, iterator end) /*reverse算法反轉指定范圍的元素@param beg 容器開始迭代器@param end 容器結束迭代器 */ reverse(iterator beg, iterator end)

4. 常用拷貝和替換算法

/*copy算法將容器內指定范圍的元素拷貝到另一容器中@param beg 容器開始迭代器@param end 容器結束迭代器@param dest 目標起始迭代器 */ copy(iterator beg, iterator end, iterator dest) /*replace算法將容器內指定范圍的舊元素修改為新元素@param beg 容器開始迭代器@param end 容器結束迭代器@param oldvalue 舊元素@param oldvalue 新元素 */ replace(iterator beg, iterator end, oldvalue, newvalue) /*replace_if算法將容器內指定范圍滿足條件的元素替換為新元素@param beg 容器開始迭代器@param end 容器結束迭代器@param callback函數回調或者謂詞(返回Bool類型的函數對象)@param oldvalue 新元素 */ replace_if(iterator beg, iterator end, _callback, newvalue) /*swap算法互換兩個容器的元素@param c1容器1@param c2容器2 */ swap(container c1, container c2)

5. 常用算數生成算法

/*accumulate算法計算容器元素累計總和@param beg 容器開始迭代器@param end 容器結束迭代器@param value累加值 */ accumulate(iterator beg, iterator end, value) /*fill算法向容器中添加元素@param beg 容器開始迭代器@param end 容器結束迭代器@param value t填充元素 */ fill(iterator beg, iterator end, value)

6. 常用集合算法

/*set_intersection算法求兩個set集合的交集注意:兩個集合必須是有序序列@param beg1 容器1開始迭代器@param end1 容器1結束迭代器@param beg2 容器2開始迭代器@param end2 容器2結束迭代器@param dest 目標容器開始迭代器@return 目標容器的最后一個元素的迭代器地址 */ set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest) /*set_union算法求兩個set集合的并集注意:兩個集合必須是有序序列@param beg1 容器1開始迭代器@param end1 容器1結束迭代器@param beg2 容器2開始迭代器@param end2 容器2結束迭代器@param dest 目標容器開始迭代器@return 目標容器的最后一個元素的迭代器地址 */ set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest) /*set_difference算法求兩個set集合的差集注意:兩個集合必須是有序序列@param beg1 容器1開始迭代器@param end1 容器1結束迭代器@param beg2 容器2開始迭代器@param end2 容器2結束迭代器@param dest 目標容器開始迭代器@return 目標容器的最后一個元素的迭代器地址 */ set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)

可能你覺得不夠深入,想要深入的話, 看源碼唄!

---------------------
作者：沉曉
來源：CSDN
原文：https://blog.csdn.net/qq_42322103/article/details/99685797

總結

以上是生活随笔為你收集整理的[转]【C/C++】STL详解的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

详解
STL

上一篇：「项目实战」一文读懂思科网络设备IOS系
下一篇： C++STL之初识容器和迭代器