【C++11】(2)从可变参数模板到lambda
目录
1 可变参数模板
1.1 基本语法及原理
C++11支持可变参数模板，也就是支持可变数量参数的函数模板和类模板。可变数目的参数叫做参数包，参数包分为两种：模板参数包和函数参数包。模板参数包表示零或多个模板参数；函数参数包表示零或多个函数参数。
格式:
template void Func(Args... args) {}
template void Func(Args&... args) {} 左值引用
template void Func(Args&&... args) {} 万能引用
使用省略号来指出一个模板参数或函数参数的表示一个包，在模板参数列表中，class...或typename...指出接下来的参数表示零或多个类型列表；在函数参数列表中，类型名后面跟...指出接下来表示零或多个形参对象列表；函数参数包可以用左值引用或右值引用表示，每个参数实例化时遵循引用折叠规则。
可变参数模板的原理跟模板类似，本质还是去实例化对应类型和个数的多个函数。
可以使用sizeof...运算符去计算参数包中参数的个数。
template<class ...Args>
void Print(Args&&... args)
{
cout << sizeof...(args) << endl;
}
int main()
{
double x = 2.0;
Print();//包里有0个参数
Print(1);//包里有1个参数
Print(1, string("xxx"));//包里有2个参数
Print(1.1, string("xxx"), x);//包里有3个参数
return 0;
}原理1：编译本质在这里结合引用折叠规则实例化出以下四个函数
void Print();
void Print(int&& arg1);
void Print(int&& arg1, string&& arg2);
void Print(double&& arg1, string&& arg2, double& arg3);原理2：更本质去看没有可变参数模板，实现出这样的多个函数参数模板才能支持这里的功能，
有了可变参数模板，就会更方便，它是类型泛化基础上叠加数量变化，让泛型编程更加灵活
void Print();
template<class T1>
void Print(T1&& arg1);
template <class T1,class T2>
void Print(T1&& arg1, T2&& arg2);
template<class T1,class T2,class T3>
void Print(T1&& arg1, T2&& arg2, T3&& arg3);1.2 参数包扩展
对于一个参数包，我们除了能计算它的参数个数，还可以扩展它，当扩展一个包时，我们还要提供用于每个扩展元素的模式，扩展一个包就是将它分解为构成的元素，对于每个元素的应用模式，获取扩展后的列表。我们通过在模式的右边放一个省略号...来触发扩展操作。具体实现看如下代码：
C++还支持更复杂的包扩展，直接将参数包一次展开依次作为实参给一个函数去处理。
//可变模板参数，参数类型可变，参数个数可变，打印参数包内容
template <class ...Args>
void Print(Args&&... args)
{
// 不支持
//可变参数模板编译时解析
//这是运行获取和解析，所以不支持
for (size_t i = 0; i < sizeof...(args); i++)
{
// 不支持
cout << args[i] << " ";
}
cout << endl;
}
template <class ...Args>
void Print(Args&&... args)
{
// 不支持
for (auto&& e : args...)
{
cout << e << " ";
}
cout << endl;
}
//包扩展（解析出参数包的内容）
void ShowList()
{
// 编译器时递归的终止条件，参数包是0个时，直接匹配这个函数
cout << endl;
}
template <class T, class ...Args>
void ShowList(T&& x, Args&&... args)
{
// 运行时逻辑，不支持
/*if (sizeof...(args) == 0)
return;*/
cout << x << " ";
// args是N个参数的参数包
// 调用ShowList，参数包的第一个传给x，剩下N-1传给第二个参数包
ShowList(args...);
}
template <class ...Args>
void Print(Args&&... args)
{
ShowList(args...);
}
int main()
{
Print();
Print(1);
Print(1, string("xxx"));
Print(1, string("xxx"), 2.2);
return 0;
}调用时本质编译器将可变参数模板通过模式的包扩展，编译器推导n个重载函数：
Print(1, string("xxx"), 2.2);
//调用时本质编译器将可变参数模板通过模式的包扩展，编译器推导的以下三个重载函数
void ShowList(double z)
{
cout << z << " ";
ShowList();
}
void ShowList(string y,double z)
{
cout << y << " ";
ShowList(z);
}
void ShowList(int x,string y, double z)
{
cout << x << " ";
ShowList(y,z);
}
void Print(int x, string y, double z)
{
ShowList(x, y, z);
}除了上述方法，还有另外一个方法来解析出参数包的内容：
// 包扩展
template <class T>
const T& GetArg(const T& x)
{
cout << x << " ";
return x;
}
template <class ...Args>
void Arguments(Args... args)
{
}
template <class ...Args>
void Print(Args... args)
{
// 注意GetArg必须返回对象，这样才能组成参数包给Arguments
Arguments(GetArg(args)...);
}
//将上面的函数模板扩展实例化为下面的函数
//void Print(int x, string y, double z)
//{
//Arguments(GetArg(x), GetArg(y), GetArg(z));
//}
int main()
{
double x = 2.2;
Print(); // 包里有0个参数
Print(1); // 包里有1个参数
Print(1, string("xxxxx")); // 包里有2个参数
Print(1.1, string("xxxxx"), x); // 包里有3个参数
return 0;
}1.3 emplace系列接口
C++11以后STL容器新增了emplace系列的接口，emplace系列的接口均为模板可变参数，功能上兼容push和insert系列，emplace还支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。
emplace_back因为走移动语义，总体而言更高效，所以推荐使用emplace系列来替代insert和push系列。
int main()
{
list<string> lt;
// 传左值，跟push_back一样，走拷贝构造
string s1("111111111111");
string s2("111111111111");
lt.emplace_back(s1);
lt.push_back(s1);
// 右值，跟push_back一样，走移动构造
lt.emplace_back(move(s1));
lt.push_back(move(s2));
lt.emplace_back("111111111111");
// 直接传参，隐式类型转换
lt.push_back("111111111111");
return 0;
}int main()
{
list<pair<string, int>> lt1;
// 跟push_back一样
// 构造pair + 拷贝/移动构造pair到list的节点中data上
pair<string, int> kv("苹果", 1);
lt1.emplace_back(kv);
// 跟push_back一样
lt1.emplace_back(move(kv));
// 这里达到的效果是push_back做不到的
//lt1.emplace_back({ "苹果", 1 }); // 不支持
lt1.emplace_back("苹果", 1 ); //
lt1.push_back({ "苹果", 1 });
return 0;
}2 一些新的类功能
2.1 默认的移动构造和移动赋值
在原来的C++类中，有六个默认成员函数：构造函数、析构函数、拷贝构造函数、拷贝赋值重载、取地址重载、const取地址重载。其中前4个最重要，后两个用处不大。C++11新增了两个默认成员函数：移动构造函数和移动赋值运算符重载。
如果自己没有实现移动构造函数，并且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个。那么编译器就会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝。对于自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
同理，如果自己没有实现移动赋值重载函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会生成一个默认移动赋值。默认生成的移动赋值函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。
如果自己提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
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:
string _name;
int _age;
};
int main()
{
Person s1;
Person s2 = s1;
Person s3 = std::move(s1);
Person s4;
s4 = std::move(s2);
return 0;
}2.2 成员变量声明时给缺省值
成员变量声明时给缺省值是给初始化列表用的，如果没有显示在初始化列表初始化，就会在初始化列表用这个缺省值初始化。这里在之前类和对象中也写过。
2.3 defult和delete
C++11可以更好地控制要使用的默认函数。假设要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。例如实现了拷贝构造函数，就不会生成移动构造了，那么就可以使用default关键字显示指定移动构造生成。
如果想要限制某些默认函数的生成，在C++98中，是将函数设置成private。在C++11中，只需在该函数声明加上=delete即可，该语句指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
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;
//Person(const Person& p) = delete;
private:
string _name;
int _age;
};3 STL中的一些变化
C++11中新增了一些新容器，array、forward_list、unordered_map、unordered_set。其中实际最有用的是unordered_map、unordered_set。
STL中容器新接口也有很多，最重要的就是右值引用和移动语义相关的push/insert/emplace系列接口和移动构造和移动赋值，还有initializer_list版本的构造、容器的范围for遍历等。这些在上一篇也详细说明了。
4 lambda
4.1 lambda表达式语法
lambda表达式本质是一个匿名函数对象，和普通函数不同的是，它可以定义在函数体内部。
lambda表达式在语法层面没有类型，所以一般用auto或者模板参数定义的对象来接收lambda对象。
lambda表达式的格式：
[capture-list] (parameters)-> return type {function boby }
其中：
[capture-list]: 捕捉列表，这个列表总是在lambda表达式的开始位置，编译器会根据[]来判定接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。捕捉列表可以传值和传引用捕捉，捕捉列表为空也不能省略。
(parameters): 参数列表，与普通函数的参数列表功能类似，如果不需要参数传递，则可以连()一起省略。
->return type: 返回值类型，用于追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可以省略。一般返回值明确的情况下，也可以省略，由编译器对返回类型进行推导。
{function boby}:函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，函数体为空也不能省略。
int main()
{
//一个简单的lambda表达式
auto add1 = [](int x, int y)->int {return x + y; };
cout << add1(100, 100) << endl;
//捕捉列表为空也不能省略
//参数列表为空可以省略
//返回类型可以省略，可以通过返回对象自动推导
//函数题不能省略
auto func1 = []
{
cout << "hello world" << endl;
};
func1();
auto swap1 = [](int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
};
int a = 0, b = 1;
swap1(a, b);
cout << a << ":" << b << endl;
return 0;
}4.2 捕捉列表
lambda表达式中默认只能用lambda函数体和参数中的变量，如果想要使用外层作用域中的变量就需要进行捕捉。
- 第一种捕捉方式是在捕捉列表中显式的传值捕捉和传引用捕捉，捕捉的多个变量用逗号分割。例如：[x,y,&z]表示x和y值捕捉，z引用捕捉。
- 第二种捕捉方式是在捕捉列表中隐式捕捉，在捕捉列表中写一个=表示隐式值捕捉，在捕捉列表写一个&表示隐式引用捕捉，这样我们lambda表达式中用了哪些变量，编译器就会自动捕捉那些变量。
- 第三种捕捉方式是在捕捉列表中混合使用隐式捕捉和显式捕捉。[=,&x]表示其他变量隐式值捕捉，x引用捕捉；[&,x,y]表示其他变量引用捕捉，x和y值捕捉。当使用混合捕捉时，第一个元素必须是&或=，并且&混合捕捉时，后面的捕捉变量必须是值捕捉，同理=混合捕捉时，后面的捕捉变量必须是引用捕捉。
lambda表达式如果在函数局部域中，它可以捕捉lambda位置之前定义的变量，不能捕捉静态局部变量和全局变量。静态局部变量和全局变量也不需要捕捉，lambda表达式可以直接使用。这也意味着lambda表达式如果定义在全局位置，捕捉列表必须为空。
默认情况下，lambda捕捉列表是被const修饰的，也就是说传值捕捉过来的对象不能修改，mutable加在参数列表的后面可以取消其常量性，也就是使用该修饰符后，传值捕捉的对象就可以修改了，但是修改还是形参对象，不会影响实参。使用该修饰符后，参数列表不可省略，即使参数列表为空。
下面根据代码来理解上述规则：
int x = 0;
//捕捉列表必须为空，因为全局变量不用捕捉就可以用，没有可被捕捉的变量
auto func1 = []() {x++; };
int main()
{
//只能用当前lambda局部域和捕捉的对象和全局对象
int a = 0, b = 1, c = 2, d = 3;
auto func1 = [a, &b]
{
//值捕捉的变量不能修改，引用捕捉的变量可以修改
++b;
return a + b;
};
cout << func1() << endl;//2
//隐式值捕捉
//用了哪些变量就捕捉哪些变量
auto func2 = [=]
{
int ret = a + b + c + d;
return ret;
};
cout << func2() << endl;//7
//隐式引用捕捉，用了哪些变量就捕捉哪些变量
auto func3 = [&]
{
a++;
b++;
c++;
d++;
};
func3();
cout << a << " " << b << " " << c << " " << d << endl;//1 3 3 4
//混合捕捉1
auto fun4 = [&, a, b]
{
//a++;b++;//错误，值捕捉不可修改
c++; ++d;
return a + b + c + d;
};
cout << fun4() << endl;//13
//混合捕捉2
auto func5 = [=, &a, &b]
{
a++; b++;
//c++;d++;//错误
return a + b + c + d;
};
cout << func5() << endl;//15
//局部的静态变量还有全局变量不能捕捉，也不需要捕捉
static int n = 0;
auto func6 = []
{
int ret = x + n;
return ret;
};
//传值捕捉本质是一种拷贝，并且被const修饰了
//mutable相当于去掉const属性，可以修改了
//修改之后不会影响外面被捕捉的值，因为是一种拷贝
auto func7 = [=]()mutable
{
a++; b++; c++; d++;
return a + b + c + d;
};
cout << func7() << endl;//19
cout << a << " " << b << " " << c << " " << d << endl;//2 4 4 5
return 0;
}4.3 lambda的应用
在学习lambda表达式之前，我们使用的可调用对象只有函数指针和仿函数对象，函数指针类型定义很繁琐，仿函数需要定义一个类，相对来说也麻烦，使用lambda去定义可调用对象，既简单又方便。
//lambda的应用
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,5},{"橙子",2.2,3},{"菠萝",1.5,4}};
//类似这种场景，在实现仿函数对象或函数指针支持的商品中
//不同项的比较，相对是比较麻烦的，用lambda就很好用
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceLess());
//使用lambda
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;
});
return 0;
}lambda在很多其他地方用起来也很好用。比如线程中定义线程的执行函数逻辑，智能指针中定制删除器等，lambda的应用还是很广泛的。
5 包装器
5.1 function
std::function是一个类模板，也是一个包装器。std::function的实例对象可以包装存储其他的可以调用对象，包括函数指针、仿函数、lambda、bind表达式等，存储的可调用对象被称为std::function的目标。若std::function不含目标，则称它为空。调用空std::function的目标导致抛出std::bad_function_call异常。使用function要用头文件<function>
#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:
Plus(int n=10)
:_n(n)
{ }
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return (a + b) * _n;
}
private:
int _n;
};
int main()
{
//包装各种调用对象
function<int(int, int)> f1 = f;
function<int(int, int)> f2 = Functor();
function<int(int, int)> f3 = [](int a, int b) {return a + b; };
cout << f1(1, 1) << endl;//2
cout << f2(1, 1) << endl;//2
cout << f3(1, 1) << endl;//2
//包装静态成员函数
//成员函数要指定类域并且前面加&才能获取地址
function<int(int, int)> f4 = &Plus::plusi;
cout << f4(1, 1) << endl;//2
//包装普通成员函数
//普通成员函数要指定类域并且前面加&才能获取地址
function<double(Plus*,double,double)> f5 = &Plus::plusd;
Plus pd;
cout << f5(&pd,1.1, 1.1) << endl;//22
function<double(Plus,double,double)> f6 = &Plus::plusd;
cout << f6(pd,1.1, 1.1) << endl;//22
function<double(Plus&&, double, double)> f7 = &Plus::plusd;
cout << f7(move(pd), 1.1, 1.1) << endl;//22
cout << f7(Plus(), 1.1, 1.1) << endl;//22
return 0;
}函数指针、仿函数、lambda等可调用对象的类型各不相同，std::function的优势就是统一类型，对他们都可以进行包装，这样在很多地方就方便声明可调用对象的类型。
5.2 bind
bind是一个函数模板，也是一个可调用对象的包装器，可以把它看做是一个函数适配器，对接收的可调用对象进行处理后返回一个可调用对象。bind可以用来调整参数个数和参数顺序。bind也在<functional>这个头文件中。
调用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为第二个参数，以此类推。这些占位符放到placeholders的一个命名空间中。
下面通过代码来理解上述规则：
#include<functional>
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
int Sub(int a, int b)
{
return (a - b) * 10;
}
int SubX(int a, int b, int c)
{
return (a - b - c) * 10;
}
class Plus
{
public:
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return a + b;
}
};
int main()
{
auto sub1 = bind(Sub, _1, _2);
cout << sub1(10, 5) << endl;//50
//bind本质是返回一个仿函数对象
//调整参数顺序（不常用）
auto sub2 = bind(Sub, _2, _1);
cout << sub2(10, 5) << endl;//-50
//调整参数个数（常用）
auto sub3 = bind(Sub, 100, _1);
cout << sub3(5) << endl;//950
auto sub4 = bind(Sub, _1, 100);
cout << sub4(5) << endl;//-950
//分别绑死第1，2，3个参数
auto sub5 = bind(SubX, 100,_1, _2);
cout << sub5(5,1) << endl;//940
auto sub6 = bind(SubX, _1, 100,_2);
cout << sub6(5,1) << endl;//-960
auto sub7 = bind(SubX, _1, _2,100);
cout << sub7(5,1) << endl;//-960
// 成员函数对象进行绑死，就不需要每次都传递了
function<double(Plus&&, double, double)> f6 = &Plus::plusd;
Plus pd;
cout << f6(move(pd), 1.1, 1.1) << endl;//2.2
cout << f6(Plus(), 1.1, 1.1) << endl;//2.2
function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2);
cout << f7(1.1, 1.1) << endl;//2.2
return 0;
}以上就是本文的全部内容了，如果这篇文章对你有用，可以点点赞哦，你的支持就是我写下去的动力，后续会不断地更新知识。
更多推荐
30
0- 0
已为社区贡献1条内容
所有评论(0)