参数包 emplace_back lambda

参数包

下面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数。我们虽然可以通过sizeof...(args)得到形参的个数，但不能遍历形参，语法不支持args[i]获取形参。

下面有两种方法获取每个形参

递归函数方式展开参数包

传过来的形参分为两部分T Args ，每次取一个T形参，剩余的形参再继续递归取。当只剩一个形参时，更符合递归终止函数，结束递归。

逗号表达式展开参数包

1.利用逗号表达式先执行左边，再以右边为结果。

2.初始化列表，通过初始化列表来初始化一个变长数组。

emplace_back

首先我们看到的emplace系列的接口，支持模板的可变参数，并且万能引用。emplace_back和push_back有什么不同呢？

对链表插入一个string对象，push_back必须先初始化一个string对象，再插入。如果插入对象是左值还需要进行拷贝构造插入。即使是插入右值，还得构造+移动构造。

而emplace只需要一次构造就可以。

emplace原理

emplace函数模板根据参数包的不同，实例化出不同的emplace函数，再找到与之相符的构造函数。

template <class... Args>
ListNode(Args&&... args): _next(nullptr), _prev(nullptr), _data(std::forward<Args>(args)...)
{}template <class... Args>
void emplace_back(Args&&... args)
{insert(end(), std::forward<Args>(args)...);
}// 原理：编译器根据可变参数模板生成对应参数的函数
/*void emplace_back(string& s)
{insert(end(), std::forward<string>(s));
}void emplace_back(string&& s)
{insert(end(), std::forward<string>(s));
}void emplace_back(const char* s)
{insert(end(), std::forward<const char*>(s));
}void emplace_back(size_t n, char ch)
{insert(end(), std::forward<size_t>(n), std::forward<char>(ch));
}*/template <class... Args>
iterator insert(iterator pos, Args&&... args)
{Node* cur = pos._node;Node* newnode = new Node(std::forward<Args>(args)...);Node* prev = cur->_prev;// prev  newnode  curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);
}

insert(end(), std::forward<Args>(args)...); 完美转发保持右值属性。

lambda

仿函数

当我们对自定义类型进行排序时，我们需要实现一个类，在类中重载operator()()，生成仿函数。通过传仿函数，取得自定义类型的比较方式。

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());
}

这样为了传比较方式，必须实现一个类，比较繁琐。如果还需要不同的比较方式，还得生成不同的类。如果根据类名看不出根据什么比较的，还得取看仿函数的实现。

因此，在C++11语法中出现了Lambda表达式。

lambda表达式语法

lambda表达式书写格式：

[capture-list] (parameters) mutable -> return-type { statement }

[capture-list] : 捕捉列表，捕捉列表能够捕捉上下文中的变量供lambda函数使用。

捕捉的是实现仿函数类的初始化参数
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以
连同()一起省略。
mutable：默认情况下，lambda函数总是一个const函数，加上mutable可以取消其常量
性。使用该修饰符时，（）不可省略(即使参数为空)。

->returntype：返回值类型。可以省略返回值类型，不管有无返回值。
{statement}：函数体。在该函数体内，除了可以使用()的参数，还可以使用[ ]捕获的参数，还有全局变量。

除了[] {} 不可以省略，不需要的话其余都可以省略。

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._price < g2._price; });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._evaluate < g2._evaluate; });sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluate > g2._evaluate; });
}

[ ]捕捉列表说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)

（传值有const修饰，加上mutable可以修改lambda可以用的变量，但出了lambda作用域就会变回原来的值。）
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)

（可以对变量进行修改，出了lambda 作用域也保持修改后的值。）

虽然我们说[=]/[&]捕获所有父作用域中的变量，但只有用到的变量才会捕获。

lambda原理

先看对比一下仿函数与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.14;Rate ret(rate);auto func = [rate](double money,double year)->double{return money * rate * year;};cout << ret(100, 5) << endl;cout << func(100, 5) << endl;}