【C++】C++11 新特性
目錄
1.列表初始化
1.1. C++98中使用{}初始化的問題
1.2. 內置類型的列表初始化
1.3. 自定義類型的列表初始化
2. 變量類型推導
2.1. 為什么需要類型推導
2.2. decltype類型推導
2.2.1 為什么需要decltype
2.2.2. decltype
3. 對默認成員的控制(default、delete)
3.1. 顯式缺省函數
3.2. 刪除默認函數
3.3. final和override
4. 右值引用
4.1. 概念
4.2. 右值與左值
4.3. 左值引用與右值引用
4.4. 左值引用的缺陷
4.5. 移動語義
4.6. 移動構造和移動賦值
4.7. 完美轉發
5. lambda表達式
5.1. lambda表達式語法
6. 包裝器
6.1. 為什么需要包裝器
6.2. 包裝器的使用
6.3. bind包裝器
6.3.1. bind包裝器改變參數位置
6.3.2. bind包裝器綁定固定參數
7. thread線程庫
7.1. thread線程庫函數介紹
7.2. 線程函數參數
7.3. lock_guard與unique_lock
7.3.1. Mutex的種類
7.3.2. lock_guard
7.3.3. unique_lock
7.4. 原子性操作庫(atomic)
8. 條件變量(condition_variable)
1.列表初始化
1.1. C++98中使用{}初始化的問題
在C++98中，標準允許使用花括號{}對數組元素進行統一的列表初始值設定。比如：
int array1[] = {1,2,3,4,5}; int array2[5] = {0};對于一些自定義的類型，卻無法使用這樣的初始化。比如：
vector<int> v{1,2,3,4,5};就無法通過編譯，導致每次定義vector時，都需要先把vector定義出來，然后使用循環對其賦初始值，非常不方便。C++11為了兼容C語言的這種特性，擴大了用大括號括起的列表(初始化列表)的使用范圍，使其可用于所有的內置類型和用戶自定義的類型，使用初始化列表時，可添加等號(=)，也可不添加。
1.2. 內置類型的列表初始化
int main() { // 內置類型變量 int x1 = {10}; int x2{10}; int x3 = 1+2; int x4 = {1+2}; int x5{1+2}; // 數組 int arr1[5] {1,2,3,4,5}; int arr2[]{1,2,3,4,5}; // 動態數組，在C++98中不支持 int* arr3 = new int[5]{1,2,3,4,5}; // 標準容器 vector<int> v{1,2,3,4,5}; map<int, int> m{{1,1}, {2,2,},{3,3},{4,4},make_pair(5,5)}; return 0; }注意：列表初始化可以在{}之前使用等號，其效果與不使用=沒有什么區別.
1.3. 自定義類型的列表初始化
1.標準庫支持單個對象的列表初始化
class Point { public:Point(int x = 0, int y = 0): _x(x), _y(y){} private:int _x;int _y; }; int main() {Pointer p{ 1, 2 };return 0; }2.多個對象的列表初始化
多個對象想要支持列表初始化，需給該類(模板類)添加一個帶有initializer_list類型參數的構造函數即可。注意：initializer_list是系統自定義的類模板，該類模板中主要有三個方法：begin()、end()迭代器以及獲取區間中元素個數的方法size()。
其底層可以看作是使用數組暫時將需要初始化的數據存儲起來。
例如：這里簡單實現以下vector底層的初始化列表：
#include <initializer_list> template<class T> class Vector { public:Vector(initializer_list<T> l): _capacity(l.size()), _size(0) {_array = new T[_capacity];for(auto e : l)_array[_size++] = e; } Vector<T>& operator=(initializer_list<T> l) {_array = new T[_capacity];size_t i = 0;for (auto e : l)_array[i++] = e;return *this; }private:T* _array;size_t _capacity;size_t _size; };2. 變量類型推導
2.1. 為什么需要類型推導
在定義變量時，必須先給出變量的實際類型，編譯器才允許定義，但有些情況下可能不知道需要實際類型怎么給，或者類型寫起來特別復雜，比如：
#include <map> #include <string> int main() {short a = 32670;short b = 32670;// c如果給成short，會造成數據丟失，如果能夠讓編譯器根據a+b的結果推導c的實際類型，就不會存在問題short c = a + b;std::map<std::string, std::string> m{{"apple", "蘋果"}, {"banana","香蕉"}};// 使用迭代器遍歷容器, 迭代器類型太繁瑣std::map<std::string, std::string>::iterator it = m.begin();while(it != m.end()){cout<<it->first<<" "<<it->second<<endl;++it;}return 0; }C++11中，可以使用auto來根據變量初始化表達式類型推導變量的實際類型，可以給程序的書寫提供許多方便。將程序中c與it的類型換成auto，程序可以通過編譯，而且更加簡潔。
#include <map> #include <string> int main() {std::map<std::string, std::string> m{{"apple", "蘋果"}, {"banana","香蕉"}};auto it = m.begin();while(it != m.end()){cout<<it->first<<" "<<it->second<<endl;++it;}return 0; }2.2. decltype類型推導
2.2.1 為什么需要decltype
auto使用的前提是：必須要對auto聲明的類型進行初始化，否則編譯器無法推導出auto的實際類型。但有時候可能需要根據表達式運行完成之后結果的類型進行推導，因為編譯期間，代碼不會運行，此時auto也就無能為力。
template<class T1, class T2> T1 Add(const T1& left, const T2& right) {return left + right; }template<class T1, class T2> auto Add(const T1& left, const T2& right) // 將返回值類型換成auto去自動推導，這里就會出錯 {return left + right; }如果能用加完之后結果的實際類型作為函數的返回值類型就不會出錯，但這需要程序運行完才能知道結果的實際類型，即RTTI(Run-Time Type Identification 運行時類型識別)。
C++98中確實已經支持RTTI：typeid只能查看類型不能用其結果類定義類型dynamic_cast只能應用于含有虛函數的繼承體系中運行時類型識別的缺陷是降低程序運行的效率。
2.2.2. decltype
decltype是根據表達式的實際類型推演出定義變量時所用的類型，比如：
1.推演表達式類型作為變量的定義類型
int main() {int a = 10;int b = 20;// 用decltype推演a+b的實際類型，作為定義c的類型decltype(a+b) c;cout<<typeid(c).name()<<endl; // typeid只能用作打印出對象的類型return 0; }2. 推演函數返回值的類型
void* func(size_t size) {return malloc(size); } int main() {// 如果沒有帶參數，推導函數的類型cout << typeid(decltype(func)).name() << endl;// 如果帶參數列表，推導的是函數返回值的類型,注意：此處只是推演，不會執行函數cout << typeid(decltype(func(0))).name() <<endl;return 0; }3. 對默認成員的控制(default、delete)
在C++中對于 空類編譯器會生成一些默認的成員函數，比如： 構造函數、拷貝構造函數、運算符重載、析構函數和&和const&的重載、移動構造、移動拷貝構造等函數。如果在類中顯式定義了，編譯器將不會重新生成默認版本。 有時候這樣的規則可能被忘記，最常見的是聲明了帶參數的構造函數，必要時則需要定義不帶參數的版本以實例化無參的對象。而且 有時編譯器會生成，有時又不生成，容易造成混亂，于是C++11讓程序員可以控制是否需要編譯器生成。3.1. 顯式缺省函數
在C++11中，可以在默認函數定義或者聲明時加上=default，從而顯式的指示編譯器生成該函數的默認版本，用=default修飾的函數稱為顯式缺省函數。
比如看以下代碼：
#include<iostream> #include<string> using namespace std;class person { public://person(){}//person() = default;person(const person& p) //這里由于顯式的創建拷貝構造，所以編譯器不會默認生成構造函數，因為拷貝構造也是特殊的構造函數{_age = p._age;_name = p._name;} private:int _age;string _name; };int main() {person p1; // 由于編譯器沒有生成默認構造函數，所以這里在定義對象p1時會找不到默認的構造函數導致出錯person p2 = p1; return 0; }所以這時，如果不想顯式的寫出構造函數，就可以使用default，這樣編譯器就會認為并沒有默認構造函數，就會自動生成。
person() = default;3.2. 刪除默認函數
如果能想要限制某些默認函數的生成，在C++98中，是該函數設置成private，并且不給定義，這樣只要其他人想要調用就會報錯。在C++11中更簡單，只需在該函數聲明加上=delete即可，該語法指示編譯器不生成對應函數的默認版本，稱=delete修飾的函數為刪除函數。
例如：不想讓一個類對象進行拷貝構造
class person { public:person(int age = 10, string name = "edward"):_age(age),_name(name){}person(const person& p) = delete; // C++11做法，使用delete關鍵字private:int _age;string _name;person(const person& p); // C++98做法：將拷貝構造私有，并且只聲明不實現 };int main() {person p1;return 0; }3.3. final和override
這兩個關鍵字也是C++11新增的，但是其實我們在學習繼承和多態的時候已經見過了，這里不再過多描述。
final：修飾類，使該類不能被繼承；修飾虛函數，該虛函數不能被重寫。
override：檢查派生類虛函數是否重寫了基類某個虛函數，如果沒有重寫編譯報錯
4. 右值引用
4.1. 概念
C++98中提出了引用的概念，引用即別名，引用變量與其引用實體公共同一塊內存空間，而引用的底層是通過指針來實現的，因此使用引用，可以提高程序的可讀性。
為了提高程序運行效率，C++11中引入了右值引用，右值引用也是別名，但其只能對右值引用。
int fun(int n) {return n - 1; }int main() {int x = 1, y = 2;int&& a = 10; // 引用常量int&& b = x + y; // 引用表達式int&& c = fun(2); // 引用函數返回值return 0; }4.2. 右值與左值
左值與右值是C語言中的概念，但C標準并沒有給出嚴格的區分方式，一般認為：可以放在=左邊的，或者能夠取地址的稱為左值，只能放在=右邊的，或者不能取地址的稱為右值，但是也不一定完全正確。
關于左值與右值的區分不是很好區分，一般認為：
總結：
C語言中的純右值，比如：a+b, 100
將亡值。比如：表達式的中間結果、函數按照值的方式進行返回。
4.3. 左值引用與右值引用
那么這里有一個問題：左值引用能否引用右值，右值引用能否引用左值？
int main() {int x = 1, y = 2;int& ra = 10; // 左值引用引用右值int& rb = x + y;int&& rra = x; // 右值引用引用左指 int&& rrb = y;return 0; }這里通過編譯器可以看到是會報錯的：
注意：
普通引用只能引用左值，不能引用右值，const引用既可引用左值，也可引用右值。C++11中右值引用：只能引用右值，一般情況不能直接引用左值，可以通過move將左值變成右值然后引用。
int main() {int x = 1, y = 2;const int& ra = x + y;int&& rra = std::move(x); // move：將x變成右值cout << ra << endl;cout << rra << endl;return 0; }4.4. 左值引用的缺陷
當我們在函數中使用引用傳傳參時幾乎是沒有任何問題的，但是當函數中的返回值使用引用返回時可能就會出現問題。
比如：我們使用string的實現作為例子
namespace wt {class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}string(const char* str = ""):_size(strlen(str)), _capacity(_size){cout << "string(char* str)" << endl;_str = new char[_capacity + 1];strcpy(_str, str);}// s1.swap(s2)void swap(string& s){::swap(_str, s._str);::swap(_size, s._size);::swap(_capacity, s._capacity);}// 拷貝構造string(const string& s):_str(nullptr), _size(0), _capacity(0){cout << "string(const string& s) -- 深拷貝" << endl;string tmp(s._str);swap(tmp);}string& operator=(const string& s){cout << "string& operator=(string s) -- 深拷貝" << endl;string tmp(s);swap(tmp);return *this;}~string(){//cout << "~string()" << endl;delete[] _str;_str = nullptr;}char& operator[](size_t pos){assert(pos < _size);return _str[pos];}void reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}void push_back(char ch){if (_size >= _capacity){size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}_str[_size] = ch;++_size;_str[_size] = '\0';}//string operator+=(char ch)string& operator+=(char ch){push_back(ch);return *this;}string operator+(char ch){string tmp(*this);push_back(ch);return tmp;}const char* c_str() const{return _str;}private:char* _str;size_t _size;size_t _capacity; // 不包含最后做標識的\0};wt::string to_string(int value){wt::string str;while (value){int val = value % 10;str += ('0' + val);value /= 10;}reverse(str.begin(), str.end());return str;} }// 場景1 // 左值引用做參數，基本完美的解決所有問題 void func1(wt::string s) {}void func2(const wt::string& s) {}// 場景2 // 左值引用做返回值，只能解決部分問題 // wt::string& operator+=(char ch) //解決了 // wt::string operator+(char ch) // 沒有解決，不能使用引用返回以前在學習拷貝構造時我們學習過，當上面的operator+這種情況，如果返回值是一個自定義類型，由于返回的是一個右值，所以在處理該函數的作用域之后，該右值會被立即銷毀。所以在返回之前，會調用一次拷貝構造將返回值臨時保存在調用該函數的棧幀中，然后再將臨時值拷貝構造給接收該函數的對象。（這里編譯器會優化為一次拷貝構造）
這里會發現：返回值、拷貝構造的臨時對象、ans每個對象創建后都有自己的獨立的空間，而且每個空間中的內容也完全相同，相當于創建了三個內容完全相同的對象，對于空間是一種浪費，程序的效率也會降低，而且臨時對象確實作用不是很大 。
4.5. 移動語義
C++11提出了移動語義概念，即：將一個對象中資源移動到另一個對象中的方式，可以有效緩解該問題。
// 移動構造string(string&& s) //創建一個空string對象:_str(nullptr), _size(0), _capacity(0){cout << "string(string&& s) -- 資源轉移" << endl;this->swap(s); // 將s內部的資源轉移給空對象，由于s是右值后面會被釋放，所以這里不會對它造成影響}// 移動賦值string& operator=(string&& s){cout << "string& operator=(string&& s) -- 轉移資源" << endl;swap(s);return *this;} int main() {wt::string s1;wt::string s2 = wt::to_string(1234);cout << endl;s1 = wt::to_string(1234);return 0; }這里我們使用to_string(1234)函數的返回值去初始化s2和賦值給s1，如果沒有移動構造和移動賦值，那么肯定是會去深拷貝的：
如果有移動構造和移動賦值則不會：
有了移動語義，應該慎用move，因為如果將一個左值給move了，那么他內部的資源就可能被轉移走了，這時再去使用這個左值對象就可能出現問題。
4.6. 移動構造和移動賦值
原來C++類中，有6個默認成員函數：
最后重要的是前4個，后兩個用處不大。默認成員函數就是我們不寫編譯器會生成一個默認的。
C++11新增了兩個:移動構造函數和移動賦值運算符重載。
針對移動構造函數和移動賦值運算符重載有一些需要注意的點如下:
如果 自己沒有實現移動構造函數，且沒有實現析構函數、拷貝構造、拷貝賦值重載中的任意一個。那么編譯器會自動生成一個默認移動構造。默認生成的移動構造函數，對于內置類型成員會執行逐成員按字節拷貝，自定義類型成員，則需要看這個成員是否實現移動構造，如果實現了就調用移動構造，沒有實現就調用拷貝構造。如果 自己沒有實現移動賦值重載函數，且沒有實現析構函數、拷貝構造、考貝賦值重載中的任意一個，那么編譯器會白動生成一個默認移動賦值。默認生成的移動構造函數，對于內置類型成員會執行逐成員按字節拷貝，白定義類型成員，則需要看這個成員是否實現移動賦值，如果實現了就調用移動賦值，沒有實現就調用拷貝賦值。(默認移動賦值跟上面移動構造完全類似)
如果 你提供了移動構造或者移動賦值，編譯器不會自動提供拷貝構造和拷貝賦值
4.7. 完美轉發
完美轉發是指在函數模板中，完全依照模板的參數的類型，將參數傳遞給函數模板中調用的另外一個函數。
假如有以下場景：
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; } template<typename T> void PerfectForward(T&& t) {Fun(t); }int main() {PerfectForward(10); // 右值int a;PerfectForward(a); // 左值PerfectForward(std::move(a)); // 右值const int b = 8;PerfectForward(b); // const 左值PerfectForward(std::move(b)); // const 右值return 0; }根據上面的代碼產生的結果我們會發現，為什么給函數中傳入的右值，再傳入Fun函數后全部匹配到了左值引用的函數？
模板中的&&不代表右值引用，而是萬能引用，其既能接收左值又能接收右值。模板的萬能引用只是提供了能夠接收同時接收左值引用和右值引用的能力，
但是引用類型的唯一作用就是限制了接收的類型，后續使用中都退化成了左值，
由于傳入的是右值，所以PerfectForward函數在接收他時會創建一塊臨時的空間保存它，這時這個右值就可以被取地址了，所以它的屬性就變成了右值！
我們希望能夠在傳遞過程中保持它的左值或者右值的屬性, 就需要用我們下面學習的完美轉發：
Fun(std::forward<T>(t)); //forward<T> 完美轉發：將參數按照傳遞給轉發函數的實際類型轉給目標函數，而不產生額外的開銷所謂完美：函數模板在向其他函數傳遞自身形參時，如果相應實參是左值，它就應該被轉發為左值；如果相應實參是右值，它就應該被轉發為右值。
5. lambda表達式
從C語言的函數指針到C++98的仿函數，在有些時候使用其實很不方便，特別是函數指針，所以C++11中添加了lambda表達式。
5.1. 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函數不能做任何事情。
int main() {// 最簡單的lambda表達式, 該lambda表達式沒有任何意義[]{};// 省略參數列表和返回值類型，返回值類型由編譯器推導為intint a = 3, b = 4;[=]{return a + 3; };// 省略了返回值類型，無返回值類型auto fun1 = [&](int c){b = a + c; };fun1(10)cout<< a <<" "<<b<<endl;// 各部分都很完善的lambda函數auto fun2 = [=, &b](int c)->int{return b += a+ c; };cout<<fun2(10)<<endl;// 賦值捕捉xint x = 10;auto add_x = [x](int a) mutable { x *= 2; return a + x; };cout << add_x(10) << endl;return 0; }通過上述例子可以看出，lambda表達式實際上可以理解為無名函數，該函數無法直接調用，如果想要直接調用，可借助auto將其賦值給一個變量。
捕獲列表說明
捕捉列表描述了上下文中那些數據可以被lambda使用，以及使用的方式傳值還是傳引用。
[var]：表示值傳遞方式捕捉變量var[=]：表示值傳遞方式捕獲所有父作用域中的變量(包括this)
[&var]：表示引用傳遞捕捉變量var
[&]：表示引用傳遞捕捉所有父作用域中的變量(包括this)
[this]：表示值傳遞方式捕捉當前的this指針
注意：
a. 父作用域指包含lambda函數的語句塊
b. 語法上捕捉列表可由多個捕捉項組成，并以逗號分割。
比如：[=, &a, &b]：以引用傳遞的方式捕捉變量a和b，值傳遞方式捕捉其他所有變量 [&，a, this]：值傳遞方式捕捉變量a和this，引用方式捕捉其他變量
c. 捕捉列表不允許變量重復傳遞，否則就會導致編譯錯誤。 比如：[=, a]：=已經以值傳遞方式捕捉了所有變量，捕捉a重復
d. 在塊作用域以外的lambda函數捕捉列表必須為空。
e. 在塊作用域中的lambda函數僅能捕捉父作用域中局部變量，捕捉任何非此作用域或者非局部變量都會導致編譯報錯。
f. lambda表達式之間不能相互賦值，即使看起來類型相同
實際在底層編譯器對于lambda表達式的處理方式，完全就是按照函數對象的方式處理的，即：如果定義了一個lambda表達式，編譯器會自動生成一個類，在該類中重載了operator()。
6. 包裝器
6.1. 為什么需要包裝器
function包裝器 也叫作適配器。C++中的function本質是一個類模板，也是一個包裝器。
- func可能是什么呢？那么func可能是函數名？函數指針？函數對象(仿函數對象)？也有可能
- 是lamber表達式對象？所以這些都是可調用的類型！
- 如此豐富的類型，可能會導致模板的效率低下! 為什么呢？
-
- 由于函數指針、仿函數、lambda表達式是不同的類型，因此useF函數會被實例化出三份，三次調用useF函數所打印count的地址也是不同的。
- 但實際這里根本沒有必要實例化出三份useF函數，因為三次調用useF函數時傳入的可調用對象雖然是不同類型的，但這三個可調用對象的返回值和形參類型都是相同的。
使用包裝器可以解決這里的問題：
template <class T> function; template <class Ret, class... Args> class function<Ret(Args...)>;模板參數說明
- Ret ：被包裝的可調用對象的返回值類型。
- Args... ：被包裝的可調用對象的形參類型。
6.2. 包裝器的使用
function包裝器可以對可調用對象進行包裝，包括函數指針（函數名）、仿函數（函數對象）、lambda表達式、類的成員函數
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() {//函數名function<double(double)> func1 = f;cout << useF(func1, 22.22) << endl;//函數對象function<double(double)> func2 = Functor();cout << useF(func2, 33.33) << endl;//lambda表達式function<double(double)> func3 = [](double d)->double {return d / 4; };cout << useF(func3, 44.44) << endl;return 0; }用包裝器分別對著三個可調用對象進行包裝，然后再用這三個包裝后的可調用對象來調用useF函數，這時就只會實例化出一份useF函數。
根本原因就是因為包裝后，這三個可調用對象都是相同的function類型，因此最終只會實例化出一份useF函數，該函數的第一個模板參數的類型就是function類型的。
當包裝器包裝類的非靜態成員函數時需要額外注意：
class Plus { public:static int plusi(int a, int b){return a + b;}double plusd(double a, double b){return a + b;} }; int main() {function<double(Plus, double, double)> func5 = &Plus::plusd; //&不可省略cout << func5(Plus(), 1.1, 2.2) << endl; // 需要傳入類對象去調用類中的非靜態成員函數return 0; }6.3. bind包裝器
bind也是一種函數包裝器，也叫做適配器。它可以接受一個可調用對象，生成一個新的可調用對象來“適應”原對象的參數列表。
bind函數模板的原型
template <class Fn, class... Args> bind(Fn&& fn, Args&&... args);template <class Ret, class Fn, class... Args> bind(Fn&& fn, Args&&... args);- fn : 可調用對象。
- args... ：要綁定的參數列表：值或占位符。
6.3.1. bind包裝器改變參數位置
int Plus(int a, int b) {return a - b; }int main() {function<int(int, int)> func = bind(Plus, placeholders::_2, placeholders::_1);// 將參數1與參數2交換位置cout << func(1, 2) << endl; //1return 0; }綁定時第一個參數傳入函數指針這個可調用對象，但后續傳入的要綁定的參數列表依次是placeholders::2和placeholders::1，表示后續調用新生成的可調用對象時，傳入的第一個參數傳給placeholders::2，傳入的第二個參數傳給placeholders::1。
6.3.2. bind包裝器綁定固定參數
int Plus(int a, int b) {return a + b; }int main() {//綁定固定參數function<int(int)> func = bind(Plus, placeholders::_1, 10);cout << func(2) << endl; //12return 0; }- 想把Plus函數的第二個參數固定綁定為10，可以在綁定時將參數列表的placeholders::_2設置為10
- 此時調用綁定后新生成的可調用對象時就只需要傳入一個參數，它會將該值與10相加后的結果進行返回
bind包裝器的意義：
- 將一個函數的某些參數綁定為固定的值，讓我們在調用時可以不用傳遞某些參數。
- 可以對函數參數的順序進行靈活調整。
7. thread線程庫
7.1. thread線程庫函數介紹
在C++11之前，涉及到多線程問題，都是和平臺相關的，比如windows和linux下各有自己的接口，這使得代碼的可移植性比較差。
C++11中最重要的特性就是對線程進行支持了，使得C++在并行編程時不需要依賴第三方庫，而且在原子操作中還引入了原子類的概念。
要使用標準庫中的線程，必須包含< thread >頭文件。
| 函數名 | 功能 |
| thread() | 構造一個線程對象，沒有關聯任何線程函數，即沒有啟動任何線程 |
| thread(fn, args1, args2, ...) | 構造一個線程對象，并關聯線程函數fn，args1，args2，...為線程函數的參數 |
| get_id() | 獲取線程id |
| jionable() | 線程是否還在執行，joinable代表的是一個正在執行中的線程。 |
| jion() | 該函數調用后會阻塞住線程，當該線程結束后，主線程繼續執行 |
| detach() | 在創建線程對象后馬上調用，用于把被創建線程與線程對象分離開，分離的線程 變為后臺線程，創建的線程的"死活"就與主線程無關 |
注意：
例如：
#include<iostream> #include<thread> using namespace std;void func(int n) {cout << this_thread::get_id() << endl; //打印該線程的idfor (int i = 0; i < n; ++i){cout << i << endl;} }int main() {thread t1(func, 10); //創建線程//thread(func, 10).detach(); //創建匿名線程 注意：匿名線程必須在創建時將線程分離，因為后面會找不到t1.join(); //線程等待// this_thread::sleep_for(std::chrono::seconds(3)); //使當前線程休眠return 0; }其實這里線程的創建的方法與前面linux中學習的類似，只是C++11中用對象封裝了，使用起來更加方便了。
get_id()的返回值類型為id類型，id類型實際為std::thread命名空間下封裝的一個類(因為Windows和Linux下對線程id處理的方式不同，C++中為了方便跨平臺的使用所以這樣處理)，該類中包含了一個結構體：
// vs下查看 typedef struct { /* thread identifier for Win32 */void *_Hnd; /* Win32 HANDLE */unsigned int _Id; } _Thrd_imp_t;當創建一個線程對象后，并且給線程關聯線程函數，該線程就被啟動，與主線程一起運行。線程函數一般情況下可按照以下三種方式提供：
函數指針lambda表達式
函數對象
例如：
class add { public:int operator()(int x, int y){return x + y;} };int func(int x, int y) {return x + y; }int main() {int a = 10, b = 20;thread t1(func, a, b); // 函數指針thread t2([=](int, int)->int {return a + b; }, a, b); // lambda表達式function<int<int,int>> A = add();thread t3(A,a,b); // 函數對象t1.join();t2.join();t3.join();return 0; }thread類是防拷貝的，不允許拷貝構造以及賦值，但是可以移動構造和移動賦值，即將一個線程對象關聯線程的狀態轉移給其他線程對象，轉移期間不意向線程的執行。
可以通過jionable()函數判斷線程是否是有效的，如果是以下任意情況，則線程無效：
1.采用無參構造函數構造的線程對象
2.線程對象的狀態已經轉移給其他線程對象
3.線程已經調用jion或者detach結束
面試題：并發與并行的區別？
并發：
當存在多個線程時，若系統僅有一個CPU，則根本不可能真正地同時進行一個以上的線程，系統只能把CPU的運行時間劃分為若干個時間段，再將時間段分配給各個線程。在一個線程在其時間段執行時，其余線程處于掛起狀。這種方式我們稱之為并發。并行：
若系統擁有一個以上CPU時，則存在多個線程時可并行執行。當一個CPU執行一個線程時，另一個CPU可以執行另一個線程，兩個線程互不搶占CPU資源，可以同時進行。這種方式我們稱之為并行。區別：
并發和并行是即相似又有區別的兩個概念， 并行是指兩個或者多個事件在同一時刻發生；而并發是指兩個或多個事件在同一時間間隔內發生。在多道程序環境下，并發性是指在一段時間內宏觀上有多個程序在同時運行，但在單處理機系統中，每一時刻卻僅能有一道程序執行，故微觀上這些程序只能是分時地交替執行。
7.2. 線程函數參數
線程函數的參數是以值拷貝的方式拷貝到線程棧空間中的，因此：即使線程參數為引用類型，在線程中修改后也不能修改外部實參，因為其實際引用的是線程棧中的拷貝，而不是外部實參。
當然還有一種方法能夠改變參數的值，那就是指針：
注意：如果是類成員函數作為線程參數時，必須將this作為線程函數參數。
class A { public:int add(int x, int y){cout << x + y << endl;return x + y;} };int main() {A a;// 傳入順序 線程函數，實例化類指針，函數參數thread t1(&A::add, &a, 10, 20);t1.join();return 0; }7.3. lock_guard與unique_lock
在多線程環境下，如果想要保證某個變量的安全性，只要將其設置成對應的原子類型即可，即高效又不容易出現死鎖問題。但是有些情況下，我們可能需要保證一段代碼的安全性，那么就只能通過鎖的方式來進行控制。
比如兩個線程同時對一個變量進行++操作：
int x = 0;void add(int n) {for (int i = 0; i < n; ++i){x++;cout << this_thread::get_id() << "：" << x << endl;} }int main() {thread t1(add, 10000);thread t2(add, 10000);t1.join();t2.join();return 0; }上面的代碼兩個線程各自對x加了10000次，但是從結果中可以發現x最后的值只有1992，所以這其中一定出現了線程安全問題。
所以這里需要進行加鎖操作，C++11中也新增了加鎖的庫：
那么這里問題來了，這里的加鎖應該加載for循環的里面還是外面？
答案是外面。雖然加載外面看起來兩個線程就是串行運行了，但是針對這里的實際問題而言++的操作是非常快的，如果鎖加在循環里面會導致兩個線程頻繁的去競爭鎖和釋放鎖，頻繁的去切換上下文，導致對資源的消耗非常大。
int x = 0; mutex mtx; void add(int n) {mtx.lock();for (int i = 0; i < n; ++i){//mtx.lock();x++;cout << this_thread::get_id() << "：" << x << endl;//mtx.unlock();}mtx.unlock(); }int main() {thread t1(add, 10000);thread t2(add, 10000);t1.join();t2.join();return 0; }7.3.1. Mutex的種類
上述代碼的缺陷：鎖控制不好時，可能會造成死鎖，最常見的比如在鎖中間代碼返回，或者在鎖的范圍內拋異常。因此：C++11采用RAII的方式對鎖進行了封裝，即lock_guard和unique_lock。
在C++11中，Mutex總共包了四個互斥量的種類：
mutex:
C++11提供的最基本的互斥量，該類的對象之間不能拷貝，也不能進行移動。mutex最常用的三個函數:
| 函數名 | 函數功能 |
| lock() | 上鎖：鎖住互斥量 |
| unlock() | 解鎖：釋放對互斥量的所有權 |
| try_lock() | 嘗試鎖住互斥量，如果互斥量被其他線程占有，則當前線程也不會被阻塞 |
注意，線程函數調用lock()時，可能會發生以下三種情況：
- 如果該互斥量當前沒有被鎖住，則調用線程將該互斥量鎖住，直到調用 unlock之前，該線程一直擁有該鎖
- 如果當前互斥量被其他線程鎖住，則當前的調用線程被阻塞住
- 如果當前互斥量被當前調用線程鎖住，則會產生死鎖(deadlock)
線程函數調用try_lock()時，可能會發生以下三種情況：
- 如果當前互斥量沒有被其他線程占有，則該線程鎖住互斥量，直到該線程調用 unlock 釋放互斥量
- 如果當前互斥量被其他線程鎖住，則當前調用線程返回 false，而并不會被阻塞掉
- 如果當前互斥量被當前調用線程鎖住，則會產生死鎖(deadlock)
recursive_mutex :
其允許同一個線程對互斥量多次上鎖（即遞歸上鎖），來獲得對互斥量對象的多層所有權，釋放互斥量時需要調用與該鎖層次深度相同次數的 unlock()，除此之外，std::recursive_mutex 的特性和std::mutex 大致相同。
timed_mutex ：
比 std::mutex 多了兩個成員函數，try_lock_for()，try_lock_until() 。
try_lock_for()
接受一個時間范圍，表示在這一段時間范圍之內線程如果沒有獲得鎖則被阻塞住（與 std::mutex的 try_lock() 不同，try_lock 如果被調用時沒有獲得鎖則直接返回 false），如果在此期間其他線程釋放了鎖，則該線程可以獲得對互斥量的鎖，如果超時（即在指定時間內還是沒有獲得鎖），則返回 false。
try_lock_until()
接受一個時間點作為參數，在指定時間點未到來之前線程如果沒有獲得鎖則被阻塞住，如果在此期間其他線程釋放了鎖，則該線程可以獲得對互斥量的鎖，如果超時（即在指定時間內還是沒有獲得鎖），則返回 false。
7.3.2. lock_guard
std::lock_gurad 是 C++11 中定義的模板類。定義如下 :
template<class _Mutex> class lock_guard { public:// 在構造lock_gard時，_Mtx還沒有被上鎖explicit lock_guard(_Mutex& _Mtx): _MyMutex(_Mtx){_MyMutex.lock();}// 在構造lock_gard時，_Mtx已經被上鎖，此處不需要再上鎖lock_guard(_Mutex& _Mtx, adopt_lock_t): _MyMutex(_Mtx){}~lock_guard() _NOEXCEPT{_MyMutex.unlock();}lock_guard(const lock_guard&) = delete;lock_guard& operator=(const lock_guard&) = delete; private:_Mutex& _MyMutex; };lock_guard類模板主要是通過RAII的方式，對其管理的互斥量進行了封裝，在需要加鎖的地方，只需要用上述介紹的任意互斥體實例化一個lock_guard，調用構造函數成功上鎖，出作用域前，lock_guard對象要被銷毀，調用析構函數自動解鎖，可以有效避免死鎖問題。
lock_guard的缺陷：太單一，用戶沒有辦法對該鎖進行控制，因此C++11又提供了unique_lock。
7.3.3. unique_lock
與lock_gard類似，unique_lock*類模板也是采用RAII的方式對鎖進行了封裝，并且也是以獨占所有權的方式管理mutex對象的上鎖和解鎖操作，即其對象之間不能發生拷貝。在構造(或移動(move)賦值)時，unique_lock 對象需要傳遞一個 Mutex 對象作為它的參數，新創建的 unique_lock 對象負責傳入的 Mutex對象的上鎖和解鎖操作。使用以上類型互斥量實例化unique_lock的對象時，自動調用構造函數上鎖，unique_lock對象銷毀時自動調用析構函數解鎖，可以很方便的防止死鎖問題。
與lock_guard不同的是，unique_lock更加的靈活，提供了更多的成員函數：
上鎖/解鎖操作：lock、try_lock、try_lock_for、try_lock_until和unlock
修改操作：移動賦值、交換(swap：與另一個unique_lock對象互換所管理的互斥量所有權)、釋放(release：返回它所管理的互斥量對象的指針，并釋放所有權)
獲取屬性：owns_lock(返回當前對象是否上了鎖)、operator bool()(與owns_lock()的功能相同)、mutex(返回當前unique_lock所管理的互斥量的指針)。
7.4. 原子性操作庫(atomic)
多線程最主要的問題是共享數據帶來的問題(即線程安全)。如果共享數據都是只讀的，那么沒問題，因為只讀操作不會影響到數據，更不會涉及對數據的修改，所以所有線程都會獲得同樣的數據。但是，當一個或多個線程要修改共享數據時，就會產生很多潛在的麻煩 。
所謂原子操作：即不可被中斷的一個或一系列操作，C++11引入的原子操作類型，使得線程間數據的同步變得非常高效 。
對于上面的問題：兩個線程同時對一個變量進行++操作，這里就可以用到原子性操作：
#include<atomic> atomic<int> x = 0; void add(int n) {for (int i = 0; i < n; ++i){x++; // 原子操作cout << this_thread::get_id() << "：" << x << endl;} }int main() {thread t1(add, 10000);thread t2(add, 10000);t1.join();t2.join();return 0; }在C++11中，程序員不需要對原子類型變量進行加鎖解鎖操作，線程能夠對原子類型變量互斥的訪問。
更為普遍的，程序員可以使用atomic類模板，定義出需要的任意原子類型。
atmoic<T> t; // 聲明一個類型為T的原子類型變量t注意：原子類型通常屬于"資源型"數據，多個線程只能訪問單個原子類型的拷貝，因此在C++11中，原子類型只能從其模板參數中進行構造，不允許原子類型進行拷貝構造、移動構造以及operator=等，為了防止意外，標準庫已經將atmoic模板類中的拷貝構造、移動構造、賦值運算符重載默認刪除掉了。
#include <atomic> int main() {atomic<int> a1(0);//atomic<int> a2(a1); // 編譯失敗atomic<int> a2(0);//a2 = a1; // 編譯失敗return 0; }8. 條件變量(condition_variable)
在學習Linux時我們學到過條件變量，在C++11中也增加了條件變量。
問題：如果實現一個線程打印偶數，一個線程打印奇數，且兩個線程交替打印？
如果我們使用前面學過的加鎖來試一試：
int main() {int end = 100;int i = 0;mutex mtx;thread t1([end, &i, &mtx] {while (i < end){unique_lock<mutex> lock(mtx);this_thread::sleep_for(std::chrono::milliseconds(100));cout << this_thread::get_id() << "->" << i << endl;++i;}});thread t2([end, &i, &mtx] {while (i < end){unique_lock<mutex> lock(mtx);this_thread::sleep_for(std::chrono::milliseconds(100));cout << this_thread::get_id() << "->" << i << endl;++i;}});t1.join();t2.join();return 0; }通過結果我們可以看到，上面的方法根本不能實現交替打印奇偶數，甚至一個線程打印了多次。
所以這里可以使用互斥鎖+條件變量解決：條件變量可以因為一個條件的不滿足而使線程陷入休眠狀態，并且釋放已經申請到的鎖，直到條件滿足才會喚醒線程。
注意：Predicate是一個可調用的對象或函數，他的結果會決定線程是否進入等待，具體實現為下圖所示，若while條件成立，會去調用wait函數。
這里條件變量停止等待的條件時pred為真。
#include<condition_variable> int main() {int end = 100;int i = 0;mutex mtx;condition_variable cv;bool flag = false;//打印偶數thread t1([end, &i, &mtx,&cv,&flag] {while (i < end){unique_lock<mutex> lock(mtx);// flag=false,返回true,t1不會等待cv.wait(lock, [&flag] {return !flag; });this_thread::sleep_for(std::chrono::milliseconds(100));cout << this_thread::get_id() << "->" << i << endl;++i;flag = true;cv.notify_one();}});//打印奇數thread t2([end, &i, &mtx, &cv, &flag] {while (i < end){unique_lock<mutex> lock(mtx);// flag = false，返回false，t2會等待，如果申請到了鎖也會釋放cv.wait(lock, [&flag] {return flag; });this_thread::sleep_for(std::chrono::milliseconds(100));cout << this_thread::get_id() << "->" << i << endl;++i;flag = false;cv.notify_one();}});t1.join();t2.join();return 0; }總結
以上是生活随笔為你收集整理的【C++】C++11 新特性的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 新IT引领新经济 新华三惠州云博会展现“
- 下一篇： 学了皮毛，你如何能做Web安全工程师？