C++11新特性【下】{lambda表達式、可變模板參數、包裝器}

一、lambda表達式

在C++98中，如果想要對一個數據集合中的元素進行排序，可以使用std::sort方法。如果待排序元素為自定義類型，需要用戶定義排序時的比較規則，隨著C++語法的發展，人們開始覺得上面的寫法太復雜了，每次為了實現一個algorithm算法，都要重新去寫一個類，如果每次比較的邏輯不一樣，還要去實現多個類，特別是相同類的命名，這些都給編程者帶來了極大的不便。因此，在C++11語法中出現了Lambda表達式。

1.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實現兩數相加auto add = [](int a, int b) {return a + b; };cout << add(1, 2) << endl;//lambda實現swapauto swap = [](int& a, int& b){int temp = a;a = b;b = temp;};
}

捕獲列表說明：

捕捉列表描述了上下文中那些數據可以被lambda使用，以及使用的方式傳值還是傳引用。

[var]：表示值傳遞方式捕捉變量var
[=]：表示值傳遞方式捕獲所有父作用域中的變量(包括this)
[&var]：表示引用傳遞捕捉變量var
[&]：表示引用傳遞捕捉所有父作用域中的變量(包括this)
[this]：表示值傳遞方式捕捉當前的this指針

捕捉列表還可以混合捕捉：

	int a = 1;int b = 2;int c = 3;int d = 4;//除了a b傳值捕捉外，其他的變量都是引用捕捉auto func = [&, a, b]() mutable{a++;b++;c++;d++;};func();cout << a << " " << b <<" " << c << " " << d << " " << endl;// 1 2 4 5

注意：

父作用域指包含lambda函數的語句塊
捕捉列表不允許變量重復傳遞，否則就會導致編譯錯誤。比如：[=, a]：=已經以值傳遞方式捕捉了所有變量，捕捉a重復
在塊作用域以外的lambda函數捕捉列表必須為空。
在塊作用域中的lambda函數僅能捕捉父作用域中局部變量，捕捉任何非此作用域或者非局部變量都會導致編譯報錯。
lambda表達式之間不能相互賦值，即使看起來類型相同

ps:lambda表達式的類型不是直接由語言定義的具名類型，而是編譯器為每一個lambda表達式生成的唯一的、匿名的非聯合類類型（non-union class type）。這個類型沒有名字，因此你不能用它來直接聲明變量或作為函數的參數類型。但是，你可以通過auto關鍵字或者模板來間接地引用這個類型。即使兩個表達式的內容完全相同，其類型都是不一樣的

1.2?函數對象與lambda表達式

函數對象，又稱為仿函數，即可以想函數一樣使用的對象，就是在類中重載了operator()運算符的類對象。

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);// lamberauto r2 = [=](double monty, int year)->double {return monty * rate * year;};r2(10000, 2);return 0;
}

從使用方式上來看，函數對象與lambda表達式完全一樣。函數對象將rate作為其成員變量，在定義對象時給出初始值即可，lambda表達式通過捕獲列表可以直接將該變量捕獲到。

實際在底層編譯器對于lambda表達式的處理方式，完全就是按照函數對象的方式處理的，即：如果定義了一個lambda表達式，編譯器會自動生成一個類，在該類中重載了operator()。

二、新的類功能

默認成員函數

原來C++類中，有6個默認成員函數：

構造函數
析構函數
拷貝構造函數
拷貝賦值重載
取地址重載
const 取地址重載

最后重要的是前4個，后兩個用處不大。默認成員函數就是我們不寫編譯器會生成一個默認的。 C++11 新增了兩個：移動構造函數和移動賦值運算符重載。

針對移動構造函數和移動賦值運算符重載有一些需要注意的點如下：

如果你沒有自己實現移動構造函數，且沒有實現析構函數、拷貝構造、拷貝賦值重載中的任意一個。那么編譯器會自動生成一個默認移動構造。默認生成的移動構造函數，對于內置類型成員會執行逐成員按字節拷貝，自定義類型成員，則需要看這個成員是否實現移動構造，如果實現了就調用移動構造，沒有實現就調用拷貝構造。
如果你沒有自己實現移動賦值重載函數，且沒有實現析構函數、拷貝構造、拷貝賦值重載中的任意一個，那么編譯器會自動生成一個默認移動賦值。默認生成的移動構造函數，對于內置類型成員會執行逐成員按字節拷貝，自定義類型成員，則需要看這個成員是否實現移動賦值，如果實現了就調用移動賦值，沒有實現就調用拷貝賦值。(默認移動賦值跟上面移動構造完全類似)
如果你提供了移動構造或者移動賦值，編譯器不會自動提供拷貝構造和拷貝賦值。

強制生成默認函數的關鍵字default:

C++11可以讓你更好的控制要使用的默認函數。假設你要使用某個默認的函數，但是因為一些原因這個函數沒有默認生成。比如：我們提供了拷貝構造，就不會生成移動構造了，那么我們可以使用default關鍵字顯示指定移動構造生成。

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(Person&& p) = default;private:bit::string _name;int _age;
};int main()
{Person s1;Person s2 = s1;Person s3 = std::move(s1);return 0;
}

禁止生成默認函數的關鍵字delete:

如果能想要限制某些默認函數的生成，在C++98中，是J將該函數設置成private，并且只聲明補不定義，這樣只要其他人想要調用就會報錯。在C++11中更簡單，只需在該函數聲明加上=delete即可，該語法指示編譯器不生成對應函數的默認版本，稱=delete修飾的函數為刪除函數。

class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}Person(const Person& p) = delete;
private:bit::string _name;int _age;
};
int main()
{Person s1;Person s2 = s1;Person s3 = std::move(s1);return 0;
}

三、可變模版參數

C++11的新特性可變參數模板能夠讓您創建可以接受可變參數的函數模板和類模板，相比 C++98/03，類模版和函數模版中只能含固定數量的模版參數，可變模版參數無疑是一個巨大的改進。由于可變模版參數比較抽象難懂，本篇博客主要講解其基本特性和使用方法

下面就是一個基本可變參數的函數模板：

// Args是一個模板參數包，args是一個函數形參參數包
// 聲明一個參數包Args...args，這個參數包中可以包含0到任意個模板參數。
template <class ...Args>
void ShowList(Args... args)
{}

上面的參數args前面有省略號，所以它就是一個可變模版參數，我們把帶省略號的參數稱為“參數包”，它里面包含了0到N（N>=0）個模版參數。我們無法直接獲取參數包args中的每個參數的，只能通過展開參數包的方式來獲取參數包中的每個參數，這是使用可變模版參數的一個主要特點，也是最大的難點，即如何展開可變模版參數。由于語法不支持使用args[i]這樣方式獲取可變參數，所以我們的用一些奇招來一一獲取參數包的值。

遞歸函數方式展開參數包

template<class T>
void _Show_list(const T& val)
{cout << val<<endl;
}template<class T,class ...Args>
void _Show_list(T val,Args... args)
{cout << val << " ";_Show_list(args...);
}template<class ...Args>
void Show_list(Args... args)
{_Show_list(args...);
}int main()
{Show_list(1);Show_list(1,"abc");Show_list(1,"abc",2.2);return 0;
}

底層解釋：

逗號表達式展開參數包

這種展開參數包的方式，不需要通過遞歸終止函數，是直接在expand函數體中展開的, printarg 不是一個遞歸終止函數，只是一個處理參數包中每一個參數的函數。這種就地展開參數包的方式實現的關鍵是逗號表達式。我們知道逗號表達式會按順序執行逗號前面的表達式。 expand函數中的逗號表達式：(printarg(args), 0)，也是按照這個執行順序，先執行 printarg(args)，再得到逗號表達式的結果0。同時還用到了C++11的另外一個特性——初始化列表，通過初始化列表來初始化一個變長數組, {(printarg(args), 0)...}將會展開成((printarg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... )，最終會創建一個元素值都為0的數組int arr[sizeof... (Args)]。由于是逗號表達式，在創建數組的過程中會先執行逗號表達式前面的部分printarg(args) 打印出參數，也就是說在構造int數組的過程中就將參數包展開了，這個數組的目的純粹是為了在數組構造的過程展開參數包

template<class T>
void print(const T& val)
{cout << val << " ";
}template<class ...Args>
void Show_list(Args... args)
{int arr[] = { (print(args),0)... };cout << endl;
}int main()
{Show_list(1,"abc",2.2);return 0;
}

STL容器中的empalce相關接口函數：

template <class... Args>
void emplace_back (Args&&... args);

可見emplace系列使用了可變模版參數和萬能引用，相比于emplace系列，push_back的參數存在左值引用和右值引用兩個版本，那emplace與push_back有什么區別嗎？

如果插入的數據是一個對象的話，不論是傳左值還是傳右值，兩者的效率是一摸一樣的：

emplace系列函數可以直接傳構造對象的參數包，該參數包會一直往下傳，到最底層時直接構造，相比于push_back傳右值來說省了一次移動構造的消耗

總結：

1.對于深拷貝的類，push_back傳右值和emplace傳構造對象的參數包來說，效率差不多，因為對于深拷貝來說，多一次數據交換的影響不大

2.對于淺拷貝的類來說，push_back傳右值要經歷構造和拷貝構造，emplace傳構造對象的參數包僅一次構造，此時效率提升比較大

3.推薦用emplace系列函數代替push和insert系列函數，此外emplace系列函數能傳參數包就傳參數包

四、包裝器

function包裝器

對于可調用對象一般有三種：函數指針、仿函數、lambda表達式，function包裝器也叫作適配器。C++中的function本質是一個類模板，也是一個包裝器。包裝器一般就是包裝這三種類型的。

std::function在頭文件<functional>// 類模板原型如下
template <class T> function; ? ? // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;模板參數說明：
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;std::function<double(Plus*, double, double)> func6 = &Plus::plusd;Plus plus;cout << func6(&plus, 1.1, 2.2) << endl;return 0;
}

注意：

包裝器也可以包裝類成員函數，不過要添加函數所屬類域，在c++中一般還要在類名前加一個&，對于靜態成員函數，按照函數聲明傳參即可，對于非靜態成員函數，要注意函數存在一個隱藏的this指針，我們可以傳一個對象，也可以傳一個對象的地址，底層會根據這個對象或者地址從而找到這個函數

包裝器的意義

#include<iostream>
using namespace std;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 << endl;// 函數對象cout << useF(Functor(), 11.11) << endl;cout << endl;// lamber表達式cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;cout << endl;return 0;
}

通過上面的程序驗證，我們會發現useF函數模板實例化了三份，如此豐富的可調用類型，可能會導致模板的效率低下。而包裝器就可以很好的解決上述問題。

int main()
{// 函數名std::function<double(double)> func1 = f;cout << useF(func1, 11.11) << endl;cout << endl;// 函數對象std::function<double(double)> func2 = Functor();cout << useF(func2, 11.11) << endl;cout << endl;// lamber表達式std::function<double(double)> func3 = [](double d)->double { return d /4; };cout << useF(func3, 11.11) << endl;cout << endl;return 0;
}

這樣useF就僅實例化出一份，比較節省空間

bind綁定

std::bind函數定義在頭文件中，是一個函數模板，它就像一個函數包裝器(適配器)，接受一個可調用對象（callable object），生成一個新的可調用對象來“適應”原對象的參數列表。一般而言，我們用它可以把一個原本接收N個參數的函數fn，通過綁定一些參數，返回一個接收M個（M 可以大于N，但這么做沒什么意義）參數的新函數。同時，使用std::bind函數還可以實現參數順序調整等操作。

// 原型如下：
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);// with return type (2) 
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);

可以將bind函數看作是一個通用的函數適配器，它接受一個可調用對象，生成一個新的可調用對象來“適應”原對象的參數列表。調用bind的一般形式：auto newCallable = bind(callable,arg_list); 其中，newCallable本身是一個可調用對象，arg_list是一個逗號分隔的參數列表，對應給定的 callable的參數。當我們調用newCallable時，newCallable會調用callable,并傳給它arg_list中的參數。

通過bind改變函數的參數順序

arg_list中的參數可能包含形如_n的名字，其中n是一個整數，這些參數是“占位符”，表示 newCallable的參數，它們占據了傳遞給newCallable的參數的“位置”。數值n表示生成的可調用對象中參數的位置：_1為newCallable的第一個參數，_2為第二個參數，以此類推。這些占位符存在placehoders的命名空間中

通過bind改變函數的傳參個數

void func(string s, int a, int b)
{cout << s << " " << a << " " << b << endl;
}int main()
{auto f1 = bind(func,"abc" ,placeholders::_1, placeholders::_2);f1(1, 2);auto f2 = bind(func, placeholders::_1,666, placeholders::_2);f2("def", 1);
}結果：
//abc 1 2
//def 666 1