【C++】第二十七节—C++11(下) | 可变参数模版+新的类功能+STL中一些变化+包装器
Hi，好久不见，我是云边有个稻草人，偶尔中二的C++领域博主与你分享专业知识U·ェ·U
《C++》本篇文章所属专栏—持续更新中—欢迎订阅~
目录
五、可变参数模版
1. 基本语法及原理
2. 包扩展
方式一
方式二
3. empalce系列接口
六、新的类功能
1. 默认的移动构造和移动赋值
2. 成员变量声明时给缺省值
3. defult和delete
4. final与override
七、STL中一些变化
八、包装器
1. function
2. bind
正文开始——
五、可变参数模版
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.2;Print(); // 包里有0个参数Print(1); // 包里有1个参数Print(1, string("xxxxx")); // 包里有2个参数Print(1.1, string("xxxxx"), 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);
// ...
2. 包扩展
- 对于一个参数包，我们除了能计算他的参数个数，我们能做的唯一的事情就是扩展它，当扩展一个包时，我们还要提供用于每个扩展元素的模式，扩展一个包就是将它分解为构成的元素，对每个元素应用模式，获得扩展后的列表。我们通过在模式的右边放一个省略号(...)来触发扩展操作。底层的实现细节如图一所示。见方式一
- C++还支持更复杂的包扩展，直接将参数包依次展开依次作为实参给一个函数去处理。见方式二
不支持用下面的方式去进行包扩展
// 可变模板参数
// 参数类型可变
// 参数个数可变
// 打印参数包内容
template <class ...Args>
void Print(Args... args)
{// 可变参数模板编译时解析// 下面是运行获取和解析，所以不支持这样用cout << sizeof...(args) << endl;for (size_t i = 0; i < sizeof...(args); i++){cout << args[i] << " ";}cout << endl;
}见下面使用递归的一种包扩展的方式
方式一
void ShowList()
{// 编译器时递归的终止条件，参数包是0个时，直接匹配这个函数cout << endl;
}template <class T, class ...Args>
void ShowList(T x, Args... args)
{cout << x << " ";// args是N个参数的参数包// 调用ShowList，参数包的第一个传给x，剩下N-1传给第二个参数包ShowList(args...);
}// 编译时递归推导解析参数
template <class ...Args>
void Print(Args... args)
{ShowList(args...);
}int main()
{Print(1, string("xxxxx"), 2.2);return 0;
}// 调用时
// 本质编译器将可变参数模板通过模式的包扩展，
// 编译器推导的以下三个重载函数函数
//void ShowList(double x)
//{
// cout << x << " ";ShowList();
//}//void ShowList(string x, double z)
//{
// cout << x << " ";
// 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必须返回或者到的对象，这样才能组成参数包给ArgumentsArguments(GetArg(args)...);
}// 本质可以理解为编译器编译时，包的扩展模式
// 将上面的函数模板扩展实例化为下面的函数
// 是不是很抽象，C++11以后，只能说委员会的大佬设计语法思维跳跃得太厉害
//void Print(int x, string y, double z)
//{//Arguments(GetArg(x), GetArg(y), GetArg(z));
//}int main()
{Print(1, string("xxxxx"), 2.2);return 0;
}稍稍解释一下：
3. empalce系列接口
- template void emplace_back (Args&&... args);
- template iterator emplace (const_iterator position, Args&&... args);
- C++11以后STL容器新增了empalce系列的接口，empalce系列的接口均为模板可变参数，功能上兼容push和 insert 系列，但是empalce还支持新玩法，假设容器为container，empalce还支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。
- emplace_back总体而言是更高效，推荐以后使用emplace系列替代insert和push系列
- 第二个程序中我们模拟实现了list的emplace和emplace_back接口，这里把参数包不段往下传递， 最终在结点的构造中直接去匹配容器存储的数据类型T的构造，所以达到了前面说的empalce支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。
- 传递参数包过程中，如果是 Args&&... args 的参数包，要用完美转发参数包，方式如下 std::forward(args)... ，否则编译时包扩展后右值引用变量表达式就变成了左值。
#include<list>
// emplace_back总体而言是更高效，推荐以后使用emplace系列替代insert和push系列int main()
{list<bit::string> lt;// 传左值，跟push_back一样，走拷贝构造bit::string s1("111111111111");lt.emplace_back(s1);cout << "*********************************" << endl;// 右值，跟push_back一样，走移动构造lt.emplace_back(move(s1));cout << "*********************************" << endl;// 直接把构造string参数包往下传，直接用string参数包构造string// 这里达到的效果是push_back做不到的lt.emplace_back("111111111111");cout << "*********************************" << endl;list<pair<bit::string, int>> lt1;// 跟push_back一样// 构造pair + 拷贝/移动构造pair到list的节点中data上pair<bit::string, int> kv("苹果", 1);lt1.emplace_back(kv);cout << "*********************************" << endl;// 跟push_back一样lt1.emplace_back(move(kv));cout << "*********************************" << endl;////////////////////////////////////////////////////////////////////// 直接把构造pair参数包往下传，直接用pair参数包构造pair// 这里达到的效果是push_back做不到的lt1.emplace_back("苹果", 1);//这里的参数包推出来的是const char* 和int，而不是pair，然后用pair参数包构造paircout << "*********************************" << endl;//对于push_back不能直接像上面那样写，要加上{ }//lt1.push_back("苹果", 1);lt1.push_back({"苹果", 1});return 0;
}稍稍对上面的代码解释一下：
总结：对于多参数的，push_back只能走{ }括起来的隐式类型转换，而emplace_back可以直接将多参数传给参数包，用参数包直接构造。
// List.h
namespace bit
{template<class T>struct ListNode{ListNode<T>* _next;ListNode<T>* _prev;T _data;ListNode(T&& data):_next(nullptr), _prev(nullptr), _data(move(data)){}template <class... Args>ListNode(Args&&... args): _next(nullptr), _prev(nullptr), _data(std::forward<Args>(args)...){}};template<class T, class Ref, class Ptr>struct ListIterator{typedef ListNode<T> Node;typedef ListIterator<T, Ref, Ptr> Self;Node* _node;ListIterator(Node* node):_node(node){}// ++it;Self& operator++(){_node = _node->_next;return *this;}Self& operator--(){_node = _node->_prev;return *this;}Ref operator*(){return _node->_data;}bool operator!=(const Self& it){return _node != it._node;}};template<class T>class list{typedef ListNode<T> Node;public:typedef ListIterator<T, T&, T*> iterator;typedef ListIterator<T, const T&, const T*> const_iterator;iterator begin(){return iterator(_head->_next);}iterator end(){return iterator(_head);}void empty_init(){_head = new Node();_head->_next = _head;_head->_prev = _head;}list(){empty_init();}void push_back(const T& x){insert(end(), x);}void push_back(T&& x){insert(end(), move(x));}iterator insert(iterator pos, const T& x){Node* cur = pos._node;Node* newnode = new Node(x);Node* prev = cur->_prev;// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);}iterator insert(iterator pos, T&& x){Node* cur = pos._node;Node* newnode = new Node(move(x));Node* prev = cur->_prev;// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);}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));}*/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);}private:Node* _head;};
}// Test.cpp#include"List.h"
// emplace_back总体而言是更高效，推荐以后使用emplace系列替代insert和push系列
int main()
{bit::list<bit::string> lt;// 传左值，跟push_back一样，走拷贝构造bit::string s1("111111111111");lt.emplace_back(s1);cout << "*********************************" << endl;// 右值，跟push_back一样，走移动构造lt.emplace_back(move(s1));cout << "*********************************" << endl;// 直接把构造string参数包往下传，直接用string参数包构造string// 这里达到的效果是push_back做不到的lt.emplace_back("111111111111");cout << "*********************************" << endl;bit::list<pair<bit::string, int>> lt1;// 跟push_back一样// 构造pair + 拷贝/移动构造pair到list的节点中data上pair<bit::string, int> kv("苹果", 1);lt1.emplace_back(kv);cout << "*********************************" << endl;// 跟push_back一样lt1.emplace_back(move(kv));cout << "*********************************" << endl;////////////////////////////////////////////////////////////////////// // 直接把构造pair参数包往下传，直接用pair参数包构造pair// 这里达到的效果是push_back做不到的lt1.emplace_back("苹果", 1);cout << "*********************************" << endl;return 0;
}六、新的类功能
1. 默认的移动构造和移动赋值
- 原来C++类中，有6个默认成员函数：构造函数/析构函数/拷贝构造函数/拷贝赋值重载/取地址重载/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:bit::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. 成员变量声明时给缺省值
成员变量声明时给缺省值是给初始化列表用的，如果没有显示在初始化列表初始化，就会在初始化列表用这个缺省值初始化，这个我们在类和对象部分讲过了，忘了就去复习吧。
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:bit::string _name;int _age;
};int main()
{Person s1;Person s2 = s1;Person s3 = std::move(s1);return 0;
}4. final与override
这个我们在继承和多态章节已经进行了详细讲过了，忘了就去复习吧。
七、STL中一些变化
- 下图1圈起来的就是STL中的新容器，但是实际最有用的是unordered_map和unordered_set。这 两个我们前面已经进行了非常详细的讲解，其他的大家了解一下即可。
- STL中容器的新接口也不少，最重要的就是右值引用和移动语义相关的push/insert/emplace系列 接口和移动构造和移动赋值，还有initializer_list版本的构造等，这些前面都讲过了，还有一些无关 痛痒的如cbegin/cend等需要时查查文档即可。
- 容器的范围for遍历，这个在容器部分也讲过了。
八、包装器
1. function
template <class T>
class function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;- std::function 是一个类模板，也是一个包装器。 std::function 的实例对象可以包装存储其他的可以调用对象，包括函数指针、仿函数、 lambda 、 bind 表达式等，存储的可调用对 象被称为 std::function 的目标。若 std::function 不含目标，则称它为空。调用空 std::function 的目标导致抛出 std::bad_function_call 异常。
- 以上是 function 的原型，他被定义头文件中。std::function - cppreference.com 是function的官方文件链接。
- 函数指针、仿函数、 lambda 等可调用对象的类型各不相同， std::function 的优势就是统 一类型，对他们都可以进行包装，这样在很多地方就方便声明可调用对象的类型，下面的第二个代 码样例展示了 std::function 作为map的参数，实现字符串和可调用对象的映射表功能。
#include<functional>
#include<iostream>
using namespace std;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;cout << f2(1, 1) << endl;cout << f3(1, 1) << endl;// 包装静态成员函数// 成员函数要指定类域并且前面加&才能获取地址function<int(int, int)> f4 = &Plus::plusi;cout << f4(1, 1) << endl;// 包装普通成员函数// 普通成员函数还有一个隐含的this指针参数，所以绑定时传对象或者对象的指针过去都可以function<double(Plus*, double, double)> f5 = &Plus::plusd;Plus pd;cout << f5(&pd, 1.1, 1.1) << endl;function<double(Plus, double, double)> f6 = &Plus::plusd;cout << f6(pd, 1.1, 1.1) << endl;cout << f6(pd, 1.1, 1.1) << endl;function<double(Plus&&, double, double)> f7 = &Plus::plusd;cout << f7(move(pd), 1.1, 1.1) << endl;cout << f7(Plus(), 1.1, 1.1) << endl;return 0;
}150. 逆波兰表达式求值 - 力扣（LeetCode）
// 传统方式的实现
class Solution {
public:int evalRPN(vector<string>& tokens) {stack<int> st;for (auto& str : tokens){if (str == "+" || str == "-" || str == "*" || str == "/"){int right = st.top();st.pop();int left = st.top();st.pop();switch (str[0]){case '+':st.push(left + right);break;case '-':st.push(left - right);break;case '*':st.push(left * right);break;case '/':st.push(left / right);break;}}else{st.push(stoi(str));}}return st.top();}
};妙！
/ 使用map映射string和function的方式实现
// 这种方式的最大优势之一是方便扩展，假设还有其他运算，我们增加map中的映射即可
class Solution {
public:int evalRPN(vector<string>& tokens) {stack<int> st;// function作为map的映射可调用对象的类型map<string, function<int(int, int)>> opFuncMap = {{"+", [](int x, int y) {return x + y; }},{"-", [](int x, int y) {return x - y; }},{"*", [](int x, int y) {return x * y; }},{"/", [](int x, int y) {return x / y; }}};for (auto& str : tokens){if (opFuncMap.count(str)) // 操作符{int right = st.top();st.pop();int left = st.top();st.pop();int ret = opFuncMap[str](left, right);st.push(ret);}else{st.push(stoi(str));}}return st.top();}
};2. bind
simple(1)
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 是一个函数模板，它也是一个可调用对象的包装器，可以把他看做一个函数适配器，对接收 的fn可调用对象进行处理后返回一个可调用对象。 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/_2/_3....这些占位符放到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;// bind 本质返回的一个仿函数对象// 调整参数顺序（不常用）// _1代表第一个实参// _2代表第二个实参// ...auto sub2 = bind(Sub, _2, _1);cout << sub2(10, 5) << endl;// 调整参数个数 （常用）auto sub3 = bind(Sub, 100, _1);cout << sub3(5) << endl;auto sub4 = bind(Sub, _1, 100);cout << sub4(5) << endl;// 分别绑死第123个参数auto sub5 = bind(SubX, 100, _1, _2);cout << sub5(5, 1) << endl;auto sub6 = bind(SubX, _1, 100, _2);cout << sub6(5, 1) << endl;auto sub7 = bind(SubX, _1, _2, 100);cout << sub7(5, 1) << endl;// 成员函数对象进行绑死，就不需要每次都传递了function<double(Plus&&, double, double)> f6 = &Plus::plusd;Plus pd;cout << f6(move(pd), 1.1, 1.1) << endl;cout << f6(Plus(), 1.1, 1.1) << endl;// bind一般用于，绑死一些固定参数function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2);cout << f7(1.1, 1.1) << endl;// 计算复利的lambdaauto func1 = [](double rate, double money, int year)->double {double ret = money;for (int i = 0; i < year; i++){ret += ret * rate;}return ret - money;};// 绑死一些参数，实现出支持不同年华利率，不同金额和不同年份计算出复利的结算利息function<double(double)> func3_1_5 = bind(func1, 0.015, _1, 3);function<double(double)> func5_1_5 = bind(func1, 0.015, _1, 5);function<double(double)> func10_2_5 = bind(func1, 0.025, _1, 10);function<double(double)> func20_3_5 = bind(func1, 0.035, _1, 30);cout << func3_1_5(1000000) << endl;cout << func5_1_5(1000000) << endl;cout << func10_2_5(1000000) << endl;cout << func20_3_5(1000000) << endl;return 0;
}倒计时
完——
普通朋友_陶喆
这吉他我弹定了！
至此结束——
我是云边有个稻草人
期待与你的下一次相遇......