C++【C++11】
文章目錄
- 一、統一的列表初始化
- 1.用{}來初始化元素
- 2.initializer_list
- 二、自動類型推斷
- 3.auto
- 4.decltype
- 三、指針
- 5.nullptr
- 6.范圍for
- 四、STL中的一些新變化
- 1.新增加的容器
- 2.容器內部的變化
- 五、左值引用和右值引用
- 1.什么是左值，什么是右值
- 左值
- 右值
- 那么左值引用能不能給右值取別名？
- 那么右值引用能不能給左值取別名
- 右值引用的應用
- 移動構造和移動賦值
- 移動構造
- 移動賦值
- 右值引用版本的插入
- 六、萬能引用和完美轉發
- 1.萬能引用
- 2.完美轉發
- 七、新的類功能
- 1.移動構造的自動生成條件
- default和delete
- 要求delete關鍵字實現，一個類，只能在堆上創建對象
- 繼承中的final和override關鍵字
- 八、可變參數模板
- 1.通過遞歸調用的方式取出參數包中的內容
- 2.列表初始化讀取參數包中的內容
- 3.emplace的實現
- emplace_back和我們的push_back有什么區別？
- 九、lambda表達式
- greater< int >與greater< int >()
- lambda表達式的語法
- 捕捉列表的說明
- lambda是怎么實現的
- 十、包裝器
- function包裝器
- 包裝器的一些應用場景
- 綁定bind
- 1.綁定參數調整順序
- 2.綁定參數的個數
一、統一的列表初始化
1.用{}來初始化元素
在C++98中，標準允許使用花括號{}對數組或者結構體元素進行統一的列表初始值設定。比如：
struct Point {int _x;int _y; }; int main() {int array1[] = { 1, 2, 3, 4, 5 };int array2[5] = { 0 };Point p = { 1, 2 };return 0; }但是在C++11中，我們都可以使用{}來對我們的元素進行初始化
C++11擴大了用大括號括起的列表(初始化列表)的使用范圍，使其可用于所有的內置類型和用戶自定義的類型，使用初始化列表時，可添加等號(=)，也可不添加。
2.initializer_list
C++11中有了一種新的類型，initializer_list，語法上原生支持通過大括號的方式初始化給它。它就像一個順序表一樣，支持迭代器，但是不支持插入數據。
那我們的vector等容器又是如何支持大括號的初始化的呢？
因為我們的C++11同時也對我們的庫函數進行了更新，讓我們的庫函數都支持通過initializer_list來進行構造。
這里我們查看一下vector的構造函數中多了一個構造方法，也就是我們的initializer
那如何讓我們自己之前寫過的vector支持通過initializer來初始化
測試代碼
void myvector_test18(){vector<int> v1={1,2,3,4,5,6,7,8,9,10};vector<int> v2{1,2,3,4,5,6,7,8,9,10};for(auto e:v2){cout<<e<<" ";}cout<<endl;}當然，我們的map,set,pair等容器也可以通過這種方式進行構造
#include <iostream> #include <vector> #include <list> #include <map> #include <set> #include <array> using namespace std;class Date { public:Date(int year, int month, int day):_year(year), _month(month), _day(day){cout << "Date(int year, int month, int day)" << endl;}private:int _year;int _month;int _day; };int main() {Date d1(2022, 11, 22);Date d2 = {2022, 11, 11}; Date d3{ 2022, 11, 11 };vector<Date> v3 = {d1, d2, d3};vector<Date> v4 = { { 2022, 1, 1 }, {2022, 11, 11} };string s1 = "11111";// 構造//這相當于就是隱式類型轉換//構造一個pair我們也可以通過{}的方式構造map<string, string> dict = { { "sort", "排序" }, { "insert", "插入" } };return 0; }
當然在我們的C++11的庫中，還將許多賦值也進行了重載，讓其能夠支持initializer進行賦值
下面是我們的測試代碼
總結：
C++11之后，一切對象都可以用列表初始化。但是我們建議普通對象還是用以前的方式初始化，容器可以采用花括號進行初始化。
二、自動類型推斷
3.auto
在C++98中auto是一個存儲類型的說明符，表明變量是局部自動存儲類型，但是局部域中定義局部的變量默認就是自動存儲類型，所以auto就沒什么價值了。C++11中廢棄auto原來的用法，將其用于實現自動類型推斷。這樣要求必須進行顯示初始化，讓編譯器將定義對象的類型設置為初始化值的類型。
int main() {int i = 10;auto p = &i;auto pf = strcpy;cout << typeid(p).name() << endl;cout << typeid(pf).name() << endl;map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };//如果我們這里要自己寫的話，需要寫一長串，但是使用auto的話就非常方便//map<string, string>::iterator it = dict.begin();auto it = dict.begin();return 0; }如果我們這里使用auto的話，我們上面代碼中的迭代器的類型等等，我們都不用自己手寫，就非常方便，但是我們如果使用了auto進行自動類型推斷，我們代碼的可讀性就會變差，但是有些編譯器會給你標識出來（比方說clion）。
4.decltype
typename可以推導對象的類型，但是我們不能通過這個推導出來的類型來定義我們的對象，只是單純地拿到這個類型的字符串。
但是如果我們想要用推導出來的類型重新定義一個新的對象呢？
三、指針
5.nullptr
由于C++中NULL被定義成字面量0，這樣就可能會帶來一些問題，因為0既能指針常量，又能表示整形常量。所以出于清晰和安全的角度考慮，C++11中新增了nullptr，用于表示空指針。
#ifndef NULL #ifdef __cplusplus #define NULL 0 #else #define NULL ((void *)0) #endif #endif6.范圍for
這里的范圍for和我們java中的增強for有些相似，底層是一個迭代器。
可以查看我們之前的博客中的迭代器和范圍for相關的部分
四、STL中的一些新變化
1.新增加的容器
< array >和< forward_list >顯得有些雞肋
因為< array >是固定大小的數組容器，不支持尾插和尾刪，支持[]迭代器。
C++11增加這個的初衷是為了替代c語言中的數組
< forward_list >是一個單鏈表，我們的< list >是雙向鏈表，在使用的時候其實< forward_list >插入的是在我們當前指定位置的后一個位置插入，然后erase并不是擦除當前的位置，而是擦除當前位置的下一個位置。
2.容器內部的變化
1.都支持了initializer_list構造，用來支持列表初始化
2.比較雞肋的接口，比如cbegin,cend系列
3.移動構造和移動賦值，用來對標拷貝構造和拷貝賦值，在某些場景下可以提高效率
（set&&x）;
（set& operator=(set&&x）
4.右值引用的參數的插入
五、左值引用和右值引用
1.什么是左值，什么是右值
傳統的C++語法中就有引用的語法，而C++11中新增了的右值引用語法特性，所以從現在開始我們之前學習的引用就叫做左值引用。無論左值引用還是右值引用，都是給對象取別名。
左值
什么是左值？什么是左值引用？
左值是一個表示數據的表達式(如變量名或解引用的指針)，我們可以獲取它的地址+可以對它賦值，左值可以出現賦值符號的左邊，右值不能出現在賦值符號左邊。定義時const修飾符后的左值，不能給他賦值，但是可以取它的地址。左值引用就是給左值的引用，給左值取別名。
（可以獲取到地址的就是左值）
右值
右值也是一個表示數據的表達式，如：字面常量、表達式返回值，函數返回值(這個不能是左值引用返回)等等，右值可以出現在賦值符號的右邊，但是不能出現出現在賦值符號的左邊，右值不能取地址。右值引用就是對右值的引用，給右值取別名。
int main() {double x = 1.1, y = 2.2;// 以下幾個都是常見的右值//字面量10;//表達式，傳值返回，會產生一個臨時對象x + y;//傳值返回的函數，因為會產生一個臨時對象fmin(x, y);//右值不能放到賦值符號的左邊// 這里編譯會報錯：error C2106: “=”: 左操作數必須為左值10 = 1;x + y = 1;fmin(x, y) = 1;return 0; }右值的特點就是不能取地址。
所以我們下面這樣寫的話是會報錯的
右值引用就是給我們的右值取別名。
int main() {double x = 1.1, y = 2.2;// 以下幾個都是對右值的右值引用int&& rr1 = 10;double&& rr2 = x + y;double&& rr3 = fmin(x, y); }那么左值引用能不能給右值取別名？
（左值引用可以引用右值嘛？）
int main() {// 有條件的支持// 左值引用可以引用右值嗎？ const的左值引用可以//這里的r1是不可以的，這里的r2是可以的double& r1 = x + y;const double& r2 = x + y; }右值引用是沒辦法被改變的，所以我們如果想要通過左值引用去引用一個右值，我們就需要加上const。
所以我們最好給我們的函數傳參的時候加上const，這樣的話，我們的函數既能夠接收左值也能夠接收右值
那么右值引用能不能給左值取別名
（右值引用可以引用左值嘛？不可以，需要有語法支持）
右值引用可以引用move以后的左值
左值引用可以引用右值嗎？ const的左值引用可以
右值引用可以引用左值嗎？可以引用move以后的左值
需要注意的是右值是不能取地址的，但是給右值取別名后，會導致右值被存儲到特定位置，且可以取到該位置的地址，也就是說例如：不能取字面量10的地址，但是rr1引用后，可以對rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用。
也就是可以理解成我們的右值在被右值引用之后，就變成了一個左值
int main() {double x = 1.1, y = 2.2;int&& rr1 = 10;const double&& rr2 = x + y;rr1 = 20;rr2 = 5.5; // 報錯return 0; }右值引用的應用
引用的價值：減少拷貝，尤其是深拷貝
左值引用：還可以用作輸出型參數
左值引用解決了哪些問題？
①做參數：1.減少拷貝，提高效率 2.做輸出型參數
②做返回值：1.減少拷貝，提高效率 2.引用返回可以修改返回對象（比方說operator[]就是這樣使用的）
左值引用在什么情況下有盲區？
如果我們有一個對象需要返回，那么如果我們采用的是左值引用的話，我們在將這個這個對象返回的時候，我么得這個對象已經被析構了，那么我們就沒有辦法成功返回對象。
比方說下面的情況
我們需要將上面的兩行代碼修改為下面的代碼。
//case1 to_string(int val,string&str) //case2 void generate(int numRows,vector<vector<int>& w)也就是說我們需要將我們的對象用左值引用的方式傳入我們的函數，這樣才能夠避免在我們的函數中開辟了一個對象，然后因為我們的函數執行完，這個對象被析構，沒有辦法被返回的問題。
但是這樣不符合使用習慣。
C++11出右值引用的一個重要功能就是解決上面的問題。
如何解決？
比方說我們這里寫了一個string類
移動構造和移動賦值
想要優化上面代碼中的拷貝，我們就需要實現移動構造和移動賦值。
移動構造
// 移動構造string(string&& s):_str(nullptr), _size(0), _capacity(0){cout << "string(string&& s) -- 資源轉移" << endl;swap(s);}移動賦值
// 移動賦值string& operator=(string&& s){cout << "string& operator=(string s) -- 移動賦值(資源移動)" << endl;swap(s);return *this;}相比于拷貝構造和拷貝賦值，其參數都是左值引用，如果我們這里沒有移動構造和移動賦值，因為我們上面的拷貝構造和拷貝賦值的參數為const類型的，所以我們調用左值的時候，都會走拷貝構造和拷貝賦值函數。
但是我們這里寫了移動構造和移動賦值的話，左值引用就會調用我們這里的移動構造和移動賦值。
（編譯器在匹配類型的之后，會去尋找最匹配的）
C++11又對右值進行了進一步的劃分
1、內置類型的右值：純右值
2、自定義類型的右值：將亡值
右值一般是一些字面量，函數表達式的返回值，表達式的值，這些臨時的對象的聲明周青往往就只有在它所在的那一行，所以將其稱為將亡值（資源即將被銷毀）。
（這里我們需要將這里的右值的資源給swap另外一個對象，用另外一個對象的存在，實現資源轉移。）
我們觀察到我們對象str1中的內容被拷貝到了我們的str3中
拷貝構造的代價相比移動構造更加大，拷貝構造了一個對象，我們還需要將這個舊的對象給釋放，也就是一次深拷貝，再加上一次資源的釋放。但是我們的移動構造是將我們的資源轉移過來，不需要拷貝。
本來我們下面的代碼應該是有一次拷貝構造和一次移動構造的，但是由于我們編譯器的優化，因為我們這里的str出了我們的作用域就會銷毀掉，所以我們的編譯器會將其優化，也就是直接將其識別為右值（將亡值），然后就進行資源的轉移，然后調用移動構造，然后再調用移動賦值，將str中的資源轉移到我們的ret，從而實現拷貝的減少。
zhuyuan::string to_string(int value) {zhuyuan::string str;//...//拷貝構造，返回結果作為左值return str; } int main() {//移動構造zhuyuan::string ret= to_string(-3456);return 0; }我們這里的右值引用并不是直接起作用的，而是通過移動構造和移動賦值間接起作用的。
所以我們只要實現了移動構造和移動拷貝，我們就不用像前面那樣傳入一個對象，函數操作完成，再將其返回了，更加符合我們的使用習慣（可以直接將我們的對象返回了）。
我們再來看一下庫中的實現
int main() {std::string s1("hello world");std::string s2(s1); // 拷貝構造 // std::string s3(s1+s2);//表達式的返回對象是一個將亡值，也就是一個右值，這里我們使用的就是右值拷貝std::string s3 = s1 + s2; // 移動構造std::string s4 = move(s1);return 0; }我們通過調試來觀察一下，這是初始狀態
運行到s2(s1)之后，這里是深拷貝構造
執行到s3=s1+s2，這里的s1+s2的結果是一個將亡值，這個將亡值直接被移動構造給了s3
然后運行到s4=move(s1)，這里就是一個右值引用，我們s1中的內容直接移動給了s4，我們從下面的調試中觀察到其實我們的s1中已經沒有內容了
我們觀察到在c++11之后，在我們的STL庫中的容器都提供了這個移動構造的方法
和移動賦值
右值引用版本的插入
我們觀察c++11的STL庫中還增加了右值引用版本的插入
移動構造和移動賦值解決了傳值返回這些類型對象的問題。
插入的過程中，如果傳遞對象是右值對象，那么進行資源轉移，減少拷貝，STL中的插入的接口在C++11后都會提供。
六、萬能引用和完美轉發
1.萬能引用
void Fun(int &x){ cout << "左值引用" << endl; } void Fun(const int &x){ cout << "const 左值引用" << endl; }void Fun(int &&x){ cout << "右值引用" << endl; } void Fun(const int &&x){ cout << "const 右值引用" << endl; }// 萬能引用：t既能引用左值，也能引用右值 // 引用折疊 template<typename T> void PerfectForward(T&& t) {Fun(t); } #include "list.h"int main() {PerfectForward(10);int a;PerfectForward(a); PerfectForward(std::move(a));const int b = 8;PerfectForward(b); PerfectForward(std::move(b)); return 0; }那這里的t的屬性是什么呢？
我們發現無論我們傳入的是左值還是右值，它調用的都是左值
2.完美轉發
像上面的萬能引用，我們的編譯器全部都會被處理成左值，那么我們怎么才能保持我們的傳入的參數原本的屬性呢？這里我們就需要用到我們的完美轉發
首先我們給我們自己寫的list.h加上右值引用的插入函數
void push_back(T&& x) {insert(end(), (x)); }iterator insert(iterator pos, T&& x) {Node* cur = pos._node;Node* prev = cur->_prev;Node* newnode = new Node(x);// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode); } template<typename T> void PerfectForward(T&& t) {// 完美轉發：保持t引用對象屬性Fun(std::forward<T>(t)); }#include "list.h"測試代碼int main() {PerfectForward(10); // 右值int a;PerfectForward(a); // 左值PerfectForward(std::move(a)); // 右值const int b = 8;PerfectForward(b); // const 左值PerfectForward(std::move(b)); // const 右值zhuyuan::list<zhuyuan::string> lt;zhuyuan::string s1("hello");lt.push_back(s1);cout << "----------------------------------" << endl;lt.push_back("world");return 0; }
這里我們注意到，我們的拷貝構造全部都是深拷貝，沒有匹配上我們的右值構造的版本，這是為什么？
因為我們上面的push_back中是我們上述的萬能引用，所以傳入的參數全部都被當成了左值引用，如果我們還想要使用右值引用的話，我們需要將其變成完美轉發！
OK，我們下面的終于調用了資源轉移（右值引用）。
七、新的類功能
原來的C++中，有6個默認的成員函數：
1.構造函數
2.析構函數
3.拷貝構造函數
4.拷貝賦值函數
5.取地址重載
6.const取地址重載
在C++11之后默認成員函數有8個，增加了移動構造和移動賦值運算符重載
（拷貝構造和拷貝賦值是針對于左值的拷貝（const左值引用既可以針對左值也可以針對右值））
（移動構造和移動賦值是針對右值的拷貝）
1.移動構造的自動生成條件
如果你沒有自己實現移動構造函數，且沒有實現析構函數 、拷貝構造、拷貝賦值重載中的任意一個（不過說實話，這里面只要有一個需要我們自己手寫，其他的一般也都是需要我們手寫的）。那么編譯器會自動生成一個默認移動構造。
默認生成的移動構造函數，對于內置類型成員會執行逐成員按字節拷貝，自定義類型成員，則需要看這個成員是否實現移動構造，如果實現了就調用移動構造，沒有實現就調用拷貝構造。
如果你沒有自己實現移動賦值重載函數，且沒有實現析構函數 、拷貝構造、拷貝賦值重載中的任意一個，那么編譯器會自動生成一個默認移動賦值。默認生成的移動構造函數，對于內置類型成員會執行逐成員按字節拷貝，自定義類型成員，則需要看這個成員是否實現移動賦值，如果實現了就調用移動賦值，沒有實現就調用拷貝賦值。(默認移動賦值跟上面移動構造完全類似)
如果你提供了移動構造或者移動賦值，編譯器不會自動提供拷貝構造和拷貝賦值。
1.拷貝對象需要深拷貝時，自己寫移動構造和移動賦值，比如：string，vector，list
class Person { public:Person(const char* name = "", int age = 0):_name(name), _age(age){}// 會默認生成拷貝構造+移動構造Person(const Person& p):_name(p._name),_age(p._age){}Person& operator=(const Person& p){if(this != &p){_name = p._name;_age = p._age;}return *this;}~Person(){}private:zhuyuan::string _name;int _age; };int main() {Person s1("張三", 7);Person s2 = s1; // 拷貝構造Person s3 = std::move(s1); // 移動構造 （沒有移動構造，再調用拷貝構造）return 0; }我們注意到我們這里的調用的都是拷貝構造，如果我們想要使用移動構造的話，我們就需要將我們上面自己寫的析構，拷貝，負值重載給去掉
class Person { public:Person(const char* name = "", int age = 0):_name(name), _age(age){}// 會默認生成拷貝構造+移動構造 private:zhuyuan::string _name;int _age; };int main() {Person s1("張三", 7);Person s2 = s1; // 拷貝構造Person s3 = std::move(s1); // 移動構造 （沒有移動構造，再調用拷貝構造）return 0; }
移動賦值和移動構造類似
也就是說深拷貝的類，一般都是需要我們自己手動寫的。
如果是像上面這樣的person類，讓編譯器自動生成就可以了。（自定義類型會自動調用析構）
default和delete
default
//強制編譯器生成默認的移動構造Person(Person&& p)=default;比防說我們自己寫了一個拷貝構造，那么編譯器就不會自動生成拷貝構造了，那么，想要讓我們的編譯器生成默認的移動構造的話，我們可以像上面這樣，加上一個default
delete
如果我們不想讓編譯器生成默認的構造方法，我們可以給我們的參數加上delete，這樣我們的Person對象就不能被拷貝了。
要求delete關鍵字實現，一個類，只能在堆上創建對象
// 要求delete關鍵字實現，一個類，只能在堆上創建對象 class HeapOnly { public:HeapOnly(){_str = new char[10];}//將析構變成delete，沒有一個對象能夠創建對象//因為變量出了作用域，一定要調用析構函數~HeapOnly() = delete;void Destroy(){//將空間釋放delete[] _str;//this的值就是我們的對象的地址，我們不能直接寫delete (this)，因為delete被禁用了//operator delete(this);}private:char* _str;//... };int main() {//棧//HeapOnly hp1;//靜態區//static HeapOnly hp2;//為什么new可以創建出來？//因為new出來的對象返回的是一個指針，這個指針會在堆上開辟一塊空間，并不會去調用析構函數，所以可以成功創建出來HeapOnly* ptr = new HeapOnly;//析構函數被禁用了，沒辦法用delete//delete ptr;//調用我們自己寫的Destory來釋放空間//下面兩個都是可以的ptr->Destroy();//operator delete(ptr);return 0; }繼承中的final和override關鍵字
https://blog.csdn.net/weixin_62684026/article/details/127336464
final：可以修飾我們的類，不能被繼承，虛函數不能被重寫
override：檢查子類中的虛函數是否完成了重寫，沒有完成從寫就會報錯
八、可變參數模板
可變參數也就是說可以有0個或者多個參數。
它的底層就是用一個數組去接收的，實際函數執行的時候，再去數組里面去取。
函數參數傳的是對象，變量，模板參數傳的是類型！！
函數參數可以有多個，用逗號分隔，模板參數也可以有多個。
（非類型模板參數必須是整型，其余的都得是類型）
上面的參數args前面有省略號，所以它就是一個可變模版參數，我們把帶省略號的參數稱為==“參數包”，它里面包含了0到N（N>=0）個模版參數==。我們無法直接獲取參數包args中的每個參數的，只能通過展開參數包的方式來獲取參數包中的每個參數，這是使用可變模版參數的一個主要特點，也是最大的難點，即如何展開可變模版參數。由于語法不支持使用args[i]這樣方式獲取可變參數，所以我們的用一些奇招來一一獲取參數包的值。
下面這樣直接打印args[i]的方式打開參數包是不允許的
using namespace std;//可變參數的函數模板 template <class ...Args> void ShowList(Args... args) {//可以用這種方式獲取到我們的參數包里面的參數的個數cout << sizeof...(args) << endl;// 不支持，不能這么玩for (size_t i = 0; i < sizeof...(args); ++i){cout << args[i] << " ";}cout << endl; }int main() {string str("hello");ShowList();ShowList(1);ShowList(1, 'A');ShowList(1, 'A', str);return 0; }那如果我們想要拿到參數里面的參數怎么辦呢？
首先sizeof可以幫助我們知道參數個數的多少。
1.通過遞歸調用的方式取出參數包中的內容
//當參數包中沒有任何參數的時候，會匹配這個函數，從而讓我們跳出遞歸循環 void ShowList() {cout << endl; }// Args... args代表N個參數包（N >= 0） //增加一個模板參數T template <class T, class ...Args> void ShowList(const T& val, Args... args) {cout << "ShowList("<<val<<", " << sizeof...(args) << "參數包)" <<" ";//通過遞歸推斷我們參數包里面的元素//也就是用我們的val每次都取出參數包中的第一個參數，從而實現對于我們參數包的內容的讀取ShowList(args...); }int main() {string str("hello");//第一個參數傳給上面的val，后面的參數傳給參數包ShowList(1, 'A', str);ShowList(1, 'A', str, 2, 3, 5.555);return 0; }
這樣我們的可變參數包就可以實現我們任意多個參數的傳入和接收。
2.列表初始化讀取參數包中的內容
template<class T> int PrintArg(const T& x) {cout << x << " ";return 0; }// Args... args代表N個參數包（N >= 0） template <class ...Args> void ShowList(Args... args) {//{}中有多少個值，我們的a就會開辟多大的空間，然后就會依次展開這個參數包中的內容，并且知道需要展開多少次//(因為我們的a在開辟的過程中會調用參數包的元素次構造函數，然后每一次構造的時候，就將參數包的一個元素展開，傳入我們上面的PrintArg中，然后將我們PrintArg的返回值作為我們a[]中的元素)//然后再參數包展開的過程中，我們調用PrintArg(args)，從而將已經展開的參數給打印出來int a[] = { PrintArg(args)... };cout << endl; }int main() {string str("hello");ShowList(1, 'A', str);ShowList(1, 'A', str, 2, 3, 5.555);return 0; }3.emplace的實現
這里使用萬能引用，就能夠靈活地引用各種左值和右值
emplace_back和我們的push_back有什么區別？
emplace_back可以接收多個參數，但是我們的push_back只能接收一個參數
int main() {// 沒有區別vector<int> v1;v1.push_back(1);v1.emplace_back(2);//這里我們的vector中存儲的是pair類型的vector<pair<zhuyuan::string, int>> v2;//如果是我們的push_back的話，我們一定只能傳pair結構的對象進去//因為push_back只有一個參數v2.push_back(make_pair("sort", 1));//但是如果是emplace_back的話，我們可以不make_pair，直接傳一個參數包進去//因為我們的empalce_back可以有多個參數v2.emplace_back(make_pair("sort", 1));v2.emplace_back("sort", 1);return 0; }區別在于push_back的話，先需要make_pair，make_pair需要先構造一個pair對象，然后push_back這個pair對象，這個pair對象構造出來，有可能是左值，也可能是右值，然后push_back可能調用左值版本，或者是右值版本。
也就是說，push_back的話，是構造+拷貝構造或者移動構造（左值走拷貝構造，右值走移動構造）
如果是emplace_back的話，我拿到的是pair的參數包，我們可以直接將這個參數包一直一層層傳遞，傳到最后的時候，直接用這個參數包去構造我們的pair。所以emplace_back在這種場景下會顯得更加高效。
代碼驗證：
class Date { public://構造函數Date(int year = 1, int month = 1, int day = 1):_year(year), _month(month), _day(day){cout << "Date(int year = 1, int month = 1, int day = 1)" << endl;}//拷貝構造Date(const Date& d):_year(d._year), _month(d._month), _day(d._day){cout << "Date(const Date& d)" << endl;}//拷貝賦值Date& operator=(const Date& d){cout << "Date& operator=(const Date& d))" << endl;return *this;}private:int _year;int _month;int _day; };int main() {vector<Date> v3;v3.push_back(Date(2022,11,16));cout <<"---------------------------------"<<endl;v3.emplace_back(2022, 11, 16);cout <<"---------------------------------"<<endl;list<Date> lt1;lt1.push_back(Date(2022, 11, 16));cout << "---------------------------------" << endl;lt1.emplace_back(2022, 11, 16);return 0; }
從上面的運行結果來看，我們的再vector下并沒有驗證出來，但是在list的情況下，我們觀察到emplace_back并沒有拷貝構造，因為它是將我們的參數包一層層傳到底層，然后再在底層用我們的可變參數包進行對象的構建。所以其中并沒有拷貝構造的過程。
所以在一定程度上，使用emplace_back比push_back更加高效，建議使用。
九、lambda表達式
像函數使用的對象/類型
1.函數指針
2.仿函數/函數對象
3.lambda
greater< int >與greater< int >()
我們傳類似于less或者是greater，什么時候我們要在其后面加上()？
如果是下面這種情況，我們傳遞的是對象的話，我們就需要加上()
也就是我們這里的compare comp，也就是寫greater< int >()
那如果是這種模板參數傳入類型的話，我們就不需要加上()
也就是直接寫==greater< int >==就可以了
之前我們的排序，我們需要將我們具體的排序法則傳入
struct Goods {string _name; // 名字double _price; // 價格int _evaluate; // 評價//...Goods(const char* str, double price, int evaluate):_name(str), _price(price), _evaluate(evaluate){} };struct ComparePriceLess {bool operator()(const Goods& gl, const Goods& gr){return gl._price < gr._price;} };struct ComparePriceGreater {bool operator()(const Goods& gl, const Goods& gr){return gl._price > gr._price;} };int main() {vector<Goods> v = { { "蘋果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠蘿", 1.5, 4 } };sort(v.begin(), v.end(), ComparePriceLess());sort(v.begin(), v.end(), ComparePriceGreater()); }這樣非常麻煩，還要單獨定義一個比較的函數作為參數傳入。
并且一個成員，我們就需要寫兩種比較方式，一種升序，一種降序，非常麻煩。
這時，我們就可以使用lambda表達式進行優化。
lambda表達式的語法
lambda表達式書寫格式：[capture-list] (parameters) mutable -> return-type {statement}
（捕捉列表，參數列表，返回值類型，函數體實現）
lambda表達式各部分說明：
[capture-list] : 捕捉列表，該列表總是出現在lambda函數的開始位置，編譯器根據[]來判斷接下來的代碼是否為lambda函數，捕捉列表能夠捕捉上下文中的變量供lambda函數使用。
(parameters)：參數列表。與普通函數的參數列表一致，如果不需要參數傳遞，則可以連同()一起省略（無參的時候可以省略）。
mutable：默認情況下，lambda函數總是一個const函數，mutable可以取消其常量性。使用該修飾符時，參數列表不可省略(即使參數為空)
->returntype：返回值類型。用追蹤返回類型形式聲明函數的返回值類型，沒有返回值時此部分可省略（一般都是不寫的，讓它自己推）。返回值類型明確情況下，也可省略，由編譯器對返回類型進行推導。
{statement}：函數體。在該函數體內，除了可以使用其參數外，還可以使用所有捕獲到的變量。
注意：
在lambda函數定義中，參數列表和返回值類型都是可選部分，而捕捉列表和函數體可以為空。因此C++11中最簡單的lambda函數為：[]{}; 該lambda函數不能做任何事情。
或者是省略返回值
交換變量的lambda
int main() {// 交換變量的lambdaint x = 0, y = 1;//捕捉列表，參數列表，返回值類型，函數體auto swap1 = [](int& x1, int& x2)->void{int tmp = x1; x1 = x2; x2 = tmp; };swap1(x, y);cout << x << ":" << y << endl; }lambda可以定義在局部，作為一個簡單的函數。
交換變量還可以像下面這樣寫
不傳參數交換x,y
我們可以不傳參數，然后寫一個捕捉列表
我們可以使用傳引用捕捉的方式，讓我們的x,y發生交換
int main() {// 交換變量的lambdaint x = 0, y = 1;//傳引用捕捉auto swap3 = [&x, &y]{int tmp = x;x = y;y = tmp;};swap3();cout << x << ":" << y << endl;return 0; }然后我們上面的代碼就可以這樣修改來改成我們的lambda表達式的版本，來對我們的商品進行排序
int main() {vector<Goods> v = { { "蘋果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠蘿", 1.5, 4 } };//按照名字進行升序排序sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._name < g2._name;});//按照名字進行降序排序sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._name > g2._name;});//按照價格的升序排序sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._price < g2._price;});//按照價格的降序排序sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._price > g2._price;}); }捕捉列表的說明
捕捉列表描述了上下文中那些數據可以被lambda使用，以及使用的方式傳值還是傳引用。
[var]：表示值傳遞方式捕捉變量var
[=]：表示值傳遞方式捕獲所有父作用域中的變量(包括this)
[&var]：表示引用傳遞捕捉變量var
[&]：表示引用傳遞捕捉所有父作用域中的變量(包括this)
[this]：表示值傳遞方式捕捉當前的this指針
注意：
a. 父作用域指包含lambda函數的語句塊
b. 語法上捕捉列表可由多個捕捉項組成，并以逗號分割。
比如：
[=, &a, &b]：以引用傳遞的方式捕捉變量a和b，值傳遞方式捕捉其他所有變量。（所有變量都以傳值捕捉，但是a和b用引用捕捉）
[&，a, this]：值傳遞方式捕捉變量a和this，引用方式捕捉其他變量
c. 捕捉列表不允許變量重復傳遞，否則就會導致編譯錯誤。
比如：[=, a]：=已經以值傳遞方式捕捉了所有變量，捕捉a重復
d. 在塊作用域以外的lambda函數捕捉列表必須為空。
e. 在塊作用域中的lambda函數僅能捕捉父作用域中局部變量，捕捉任何非此作用域或者非局部變量都會導致編譯報錯。
f. lambda表達式之間不能相互賦值，即使看起來類型相同
舉例：
int main() {int a,b,c,d,e;a=b=c=d=e=1;//全部傳值捕捉auto f1=[=](){cout<<a<<b<<c<<d<<e<<endl;};f1();//混合捕捉a=b=c=d=e=1;auto f2=[=,&a](){a++;cout<<a<<b<<c<<d<<e<<endl;};f2();//混合捕捉a=b=c=d=e=1;auto f3=[&,a](){b++;c++;d++;e++;cout<<a<<b<<c<<d<<e<<endl;};f3();return 0; }
lambda可以捕捉父作用域的變量
這里的父作用域值得是其lambda所在的函數，指的是當前函數所在的棧幀里面的變量。
int f=1; int main() {int a,b,c,d,e;a=b=c=d=e=1;//混合捕捉a=b=c=d=e=1;if(a){//混合捕捉auto f4=[&,a](){b++;c++;d++;e++;f++;cout<<a<<b<<c<<d<<e<<f<<endl;};f4();}return 0; }這里我們觀察到這里的全局變量也是可以捕捉到的。全局變量在數據段，靜態區，哪個位置都能夠調用到全局變量。
下面這樣寫的話就捕捉不到了
void func() {int a,b,c,d,e;a=b=c=d=e=1; } int main() {func();auto f4=[&,a](){b++;c++;d++;e++;cout<<a<<b<<c<<d<<e<<endl;};f4(); }1.對象的生命周期和存儲區域有關系
2.對象的作用域會受全局，局部，類域，命名空間域的影響
作用域關聯的是編譯器編譯的時候，用的地方能否找到的問題
現在自己所屬的域里面去找，然后再去全局去找，找不到就報錯。
捕捉列表本質上是在傳參，然后看我們的捕捉列表中的寫法，讓有的參數傳值，有的參數傳引用
lambda是怎么實現的
class Rate { public:Rate(double rate): _rate(rate){}double operator()(double money, int year){ return money * _rate * year;} private:double _rate; }; int main() { // 函數對象double rate = 0.49;Rate r1(rate);r1(10000, 2); // lambdaauto r2 = [=](double monty, int year) -> double {return monty * rate * year;};r2(10000, 2);return 0; }所以lambda調用的時候是operate()
底層是將lambda轉換成一個仿函數對象的類，然后這個類的名稱是lambda_uuid。
這里（call）調用的函數是lambda::再加上UUID（唯一標識符（基本上是唯一的）），防止我們的lambda因為重名而出現不必要的錯誤。
然后你捕捉的參數都是通過傳參傳進去的。
所以說lambd的底層其實就是一個仿函數
所以這里的lambda對于我們來說是匿名的，但是對于編譯器來說其實是有名字的。
lambda不能互相賦值的問題，由我們上面的原理中可以知道，我們兩個不同的lambda的uuid是不同的，是兩個不同的類型，所以不能相互賦值。
void (*PF)(); int main() {auto f1 = []{cout << "hello world" << endl; };auto f2 = []{cout << "hello world" << endl; }; //f1 = f2; // 編譯失敗--->提示找不到operator=() // 允許使用一個lambda表達式拷貝構造一個新的副本auto f3(f2);f3(); // 可以將lambda表達式賦值給相同類型的函數指針PF = f2;PF();return 0; }十、包裝器
function包裝器
function包裝器 也叫作適配器。C++中的function本質是一個類模板，也是一個包裝器。
template<class F, class T> T useF(F f, T x) {static int count = 0;cout << "count:" << ++count << endl;cout << "count:" << &count << endl;return f(x); }double f(double i) {return i / 2; } struct Functor {double operator()(double d){return d / 3;} }; int main() {//這里我們傳參的時候第一個參數不同，第二個參數一樣// 函數指針cout << useF(f, 11.11) << endl;// 函數對象cout << useF(Functor(), 11.11) << endl;// lamber表達式cout << useF([](double d)->double{ return d/4; }, 11.11) << endl;return 0; }這里我們觀察到我們的類模板被實例化成了三份
那有沒有辦法只實例化成一份呢？
我們就需要使用包裝器將其包裝一下
（比方說我們送禮，可以用紅包包裝一下，這樣你紅包給的多還是給得少就不會有影響了）
那為什么一定要包裝呢？
比防說遇到事件響應問題，這里我們需要先知道什么是事件？
就是發生了某個行為（我們按了一個快捷鍵組合，對應的就需要有一個響應，比方說ctrl+c就會復制）
比方說map<string,函數>，也就是我們輸入了一個string，也就是我們的快捷鍵，我們就需要從map中查找到對應的函數，并執行對應的函數，這樣我們就能夠做到事件響應。
（或者比方說網絡中的增刪查改，你傳入一個命令，它就要執行對應的操作。）
我們這里對應的行為是一個函數調用，這里的函數調用可能是函數指針，也可能是函數對象，或者是lambda表達式對象，那么我們這里的map<string,函數>的函數這里的類型應該如何去定義呢？
這里我們就需要用到包裝器進行包裝。
模板參數說明：
Ret: 被調用函數的返回類型（返回值的類型）
Args…：被調用函數的形參（可變參數的參數包，參數包作為函數的參數包）
那我們如何包裝呢
// 使用方法如下： #include <functional> int f(int a, int b) {return a + b; } struct Functor { public:int operator() (int a, int b){return a + b;} }; class Plus { public:static int plusi(int a, int b){return a + b;}double plusd(double a, double b){return a + b;} }; int main() {// 函數名(函數指針)std::function<int(int, int)> func1 = f;cout << func1(1, 2) << endl;// 函數對象std::function<int(int, int)> func2 = Functor();cout << func2(1, 2) << endl;// lamber表達式std::function<int(int, int)> func3 = [](const int a, const int b){return a + b; };cout << func3(1, 2) << endl;//綁定靜態的// 類的成員函數std::function<int(int, int)> func4 = Plus::plusi;cout << func4(1, 2) << endl;//綁定非靜態的，需要加&std::function<double(Plus, double, double)> func5 = &Plus::plusd;//成員函數的指針不能直接調用，需要用對象去調用，所以我們需要傳一個對象進去cout << func5(Plus(), 1.1, 2.2) << endl;return 0; }然后我們使用包裝器解決我們上面模板多次實例化的問題
#include <functional> template<class F, class T> T useF(F f, T x) {static int count = 0;cout << "count:" << ++count << endl;cout << "count:" << &count << endl;return f(x); } double f(double i) {return i / 2; } struct Functor {double operator()(double d){return d / 3;} }; int main() {// 函數名std::function<double(double)> func1 = f;cout << useF(func1, 11.11) << endl; // 函數對象std::function<double(double)> func2 = Functor();cout << useF(func2, 11.11) << endl; // lamber表達式std::function<double(double)> func3 = [](double d)->double{ return d /4; };cout << useF(func3, 11.11) << endl;return 0; }包裝器的一些應用場景
https://leetcode.cn/problems/evaluate-reverse-polish-notation/
這是我們之前的解題思路
https://blog.csdn.net/weixin_62684026/article/details/127023299
然后在我們學習了C++11之后，我們就可以這樣寫了
這里寫的就是一個類似于事件響應的代碼。
函數指針和仿函數可以寫出實實在在的類型，但是lambda寫不出類型，因為lambda函數對我們的使用者而言是匿名的，但是因為lambda可以用包裝器包裝，所以可以用包裝器去包裝lambda之后，然后使用我們的lambda。
綁定bind
std::bind函數定義在頭文件中，是一個函數模板，它就像一個函數包裝器(適配器)，接受一個可調用對象（callable object），生成一個新的可調用對象來“適應”原對象的參數列表。一般而言，我們用它可以把一個原本接收N個參數的函數fn，通過綁定一些參數，返回一個接收M個（M可以大于N，但這么做沒什么意義）參數的新函數。同時，使用std::bind函數還可以實現參數順序調整等操作。
（包裝器是將我們的函數包裝成一個統一類型）
（綁定可以認為是一個適配器，是對于參數進行適配的，調整參數）
可以將bind函數看作是一個通用的函數適配器，它接受一個可調用對象，生成一個新的可調用對象來“適應”原對象的參數列表。
調用bind的一般形式：auto newCallable = bind(callable,arg_list);
其中，newCallable本身是一個可調用對象，arg_list是一個逗號分隔的參數列表，對應給定的callable的參數。當我們調用newCallable時，newCallable會調用callable,并傳給它arg_list中的參數。
arg_list中的參數可能包含形如_n的名字，其中n是一個整數，這些參數是“占位符”，表示newCallable的參數，它們占據了傳遞給newCallable的參數的“位置”。數值n表示生成的可調用對象中參數的位置：_1為newCallable的第一個參數，_2為第二個參數，以此類推
（第一個參數為函數，第二個參數為參數包）
（用來確定你要綁定的參數和不綁定的參數）
1.綁定參數調整順序
using namespace placeholders; int main() { // function<int(int,int)> funcPlus=Plus; // function<int(Sub,int,int)> funcSub=&Sub::sub; // map<string,function<int(int,int)>> opFuncMap= // { // {'+', Plus}, // {'-',&Sub::sub} // };int x=10,y=2;Div(x,y);//假設我們想要調整div的參數的順序//第一個參數是可調用對象//你要調整的是形參，調整的不是實參//我們這里用占位去代表形參_1代表第一個參數，_2代表第二個參數，以此類推//調整順序//_1 _2……是定義在命名空間中的，代表綁定函數對象的形參，1代表第一個形參，_2代表第二個形參，以此類推 // bind(Div,placeholders::_1,placeholders::_2); //要么讓編譯器自動推斷auto bindFunc1=bind(Div,_1,_2);//或者這樣寫function<int(int,int)> bindFunc2=bind(Div,_1,_2);//然后我們想要調整形參的話，需要這樣寫function<int(int,int)> bindFunc3=bind(Div,_2,_1);cout<<bindFunc1(x,y)<<endl;cout<<bindFunc2(x,y)<<endl;cout<<bindFunc3(x,y)<<endl; }
所以及時你這里交換了順序，_1依舊代表的是第一個參數，_2代表的是第二個參數。
2.綁定參數的個數
#include <iostream> #include <map> #include <string> using namespace std; #include <functional>int Div(int a,int b) {return a/b; } //普通的全局函數 int Plus(int a, int b) {return a + b; }int Mul(int a, int b,int rate) {return a * b* rate; }//如果這里的Sub是一個成員函數 class Sub { public://成員函數int sub(int a, int b){return a - b;} };using namespace placeholders; int main() {//調整這個數，綁定死固定參數function<int(int,int)> funcPlus=Plus;function<int(int,int)> funcDiv=Div;//將三個參數綁定成兩個參數function<int(int,int)> funcSub=bind(&Sub::sub,Sub(),_1,_2);//這里我們直接將這個第三個參數給定為1function<int(int,int)> funcMul=bind(Mul,_1,_2,1);map<string,function<int(int,int)>> opFuncMap={{"+", funcPlus},{"-",funcSub},{"*",funcMul},{"/",funcDiv}};cout<<funcPlus(1,2)<<endl;cout<<funcSub(1,2)<<endl;cout<<funcMul(1,2)<<endl;cout<<funcDiv(5,2)<<endl;cout<<opFuncMap["+"](1,2)<<endl;cout<<opFuncMap["-"](1,2)<<endl;cout<<opFuncMap["*"](1,2)<<endl;cout<<opFuncMap["/"](5,2)<<endl; }總結
以上是生活随笔為你收集整理的C++【C++11】的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 山东春考计算机组装与维修,山东春考计算机
- 下一篇： 温柔末世，慢慢到来的末日