【C++】C++11特性的介绍和使用（第三篇）

书接上文！

一、可变参数模板

        C++11支持可变参数模板，也就是说支持可变数量参数的函数模板和类模板，可变数目的参数被称为参数包，存在两种参数包：模板参数包，表示零或多个模板参数；函数参数包：表示零或多个函数参数。

template <class ...Args> void Func(Args... args) {}
template <class ...Args> void Func(Args&... args) {}
template <class ...Args> 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个参数// 原理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);// ...return 0;
}

注意：sizeof...是运算符。

二、包扩展

        对于一个参数包，我们除了能计算他的参数个数，我们能做的唯一的事情就是扩展它，当扩展一个包时，我们还要提供用于每个扩展元素的模式，扩展一个包就是将它分解为构成的元素，对每个元素应用模式，获得扩展后的列表。我们通过在模式的右边放一个省略号(…)来触发扩展操作。底层的实现细节如图1所示。

        C++还支持更复杂的包扩展，直接将参数包依次展开依次作为实参给一个函数去处理。

错误代码示例：

	 //可变模板参数//参数类型可变//参数个数可变//打印参数包内容template <class ...Args>void Print(Args... args){// 可变参数模板编译时解析// 下⾯是运⾏获取和解析，所以不⽀持这样⽤cout << sizeof...(args) << endl;for (size_t i = 0; i < sizeof...(args); i++){cout << args[i] << " ";//不支持}}

正确代码示例：

//方法1
void ShowList()//递归终止，结束条件
{cout << endl;
}template<class T, class ...Args>
void ShowList(T&& x,Args&&... args)
{//不能这么写，这是运行时判断逻辑//if (sizeof...(args) == 0)//{//	return;//}cout << x << " ";ShowList(args...);//递归调用
}template<class ...Args>
void Print(Args&&... args)
{//N个参数，第一个传给x，剩下N-1个传给ShowList的第二个参数包ShowList(args...);
}//方法2
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)...);
}

图片解析：

 三、emplace系列接口

template <class... Args> void emplace_back(Args&&... args);
template <class... Args> iterator emplace(const_iterator position,Args&&... args);

        C++11以后STL容器新增了empalce系列的接口，empalce系列的接口均为模板可变参数,功能上兼容push和insert系列,但是empalce还支持新玩法,假设容器为container<T>,empalce还支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。        

        emplace_back总体而言是更高效,推荐以后使用emplace系列替代insert和push系列。

        第二个程序中我们模拟实现了list的emplace和emplace_back接口,这里把参数包不段往下传递，最终在结点的构造中直接去匹配容器存储的数据类型T的构造，所以达到了前面说的empalce支持直接插入构造T对象的参数，这样有些场景会更高效一些，可以直接在容器空间上构造T对象。

        传递参数包过程中，如果是Args&&...args的参数包，要用完美转发参数包，方式如下std::forward<Args>(args)...，否则编译时包扩展后右值引用变量表达式就变成了左值。

代码示例：

list<int> l1;//用法和效率一样
l1.push_back(1);
l1.emplace_back(2);list<string> l2;
//左值用法和效率一样
string s1("hhhh");
l2.push_back(s1);
l2.emplace_back(s1);//右值用法和效率一样
l2.push_back(move(s1));
l2.emplace_back(move(s1));//区别:emplace_back的效率略高一筹
l2.push_back("saaa");//构造+移动构造，不是模板
l2.emplace_back("asss");//直接构造,本质它是模板，层层推演list<pair<string, int>> l3;
//传左值效率用法一样
pair<string, int> kv1("aaa", 1);
l3.push_back(kv1);
l3.emplace_back(kv1);//传右值效率用法一样
l3.push_back(move(kv1));
l3.emplace_back(move(kv1));//区别:emplace_back的效率略高一筹
l3.push_back({ "2222222222",3 });
//l3.emplace_back({ "3333",4 });//不支持
l3.emplace_back("33333", 4);

注意：STL容器推荐使用emplace系列，但是要注意方法。

四、类的新功能

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

补充知识：委托构造

class Person
{
public:Person(const char* name = "张三", int age = 3):_name(name), _age(age){}Person(int i, const char* name, int age)//委托上面的构造函数构造:Person(name,age){_i = i;}private:string _name;int _age;int _i;
};

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

五、STL中的一些新变化

        下图圈起来的就是STL中的新容器,但是实际最有用的是unordered_map和unordered_set。这两个我们前面已经进行了非常详细的讲解，其他的大家了解一下即可。

        STL中容器的新接口也不少，最重要的就是右值引用和移动语义相关的push/insert/emplace系列接口和移动构造和移动赋值，还有initializer_list版本的构造等，这些前面的博客都讲过了，还有一些无关痛痒的如cbegin/cend等需要时查查文档即可。

        容器的范围for遍历，这个在容器部分也讲过了；其实就是for循环

 六、lambda

1) lambda表达式语法

        lambda表达式本质是一个匿名函数对象，跟普通函数不同的是他可以定义在函数内部。lambda表达式语法使用层而言没有类型，所以我们一般是用 auto 或者模板参数定义的对象去接收象lambda对象。

        lambda表达式的格式：[capture-list] (parameters)-> return type {function boby }

        [capture-list]：捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用，捕捉列表可以传值和传引用捕捉。捕捉列表为空也不能省略。

        (parameters)：参数列表，与普通函数的参数列表功能类似，如果不需要参数传递，则可以连同()一起省略。

        ->return type：返回值类型，用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。一般返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。

        {function boby}：函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，函数体为空也不能省略。

代码示例：

auto addFunc = [](int a, int b)->int {return a + b; };//简单示例：lambda表达式
//等价于auto addFunc = [](int a, int b)->{return a + b; };//使用
cout << addFunc(2, 3) << endl;//5// 1、捕捉为空也不能省略
// 2、参数为空可以省略
// 3、返回值可以省略，可以通过返回对象⾃动推导
// 4、函数题不能省略
auto func1 = []
{cout << "hello bit" << endl;return 0;
};func1();int a = 0, b = 1;
auto swap1 = [](int& x, int& y)
{int tmp = x;x = y;y = tmp;
};
swap1(a, b);
cout << a << ":" << b << endl;//1,0class A
{
public:void f(){int i = 0;//成员函数内部使用成员变量需要捕捉thisauto add2 = [this, i](int x, int y)->int {return x + y + i + _a + _b; };}
private:int _a = 3;int _b = 9;
};

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 funcl = [a, &b]{// 值(a)捕捉的变量不能修改，引⽤(&b)捕捉的变量可以修改//a++;b++;int ret = a + b;return ret;};cout << funcl() << endl;//2// 隐式值捕捉// ⽤了哪些变量就捕捉哪些变量auto func2 = [=]{int ret = a + b + c;return ret;};cout << func2() << endl;// 隐式引⽤捕捉// ⽤了哪些变量就捕捉哪些变量auto func3 = [&]{a++;c++;d++;};func3();cout << a << " " << b << " " << c << " " << d << endl;// 混合捕捉1auto func4 = [&, a, b]{//a++;//b++;c++;d++;return a + b + c + d;};func4();cout << a << " " << b << " " << c << " " << d << endl;auto func2 = [&, a]//不能倒过来写 auto func2=[a,&]{b++;c++;d++;};// 混合捕捉2auto func5 = [=, &a, &b]{a++;b++;/*c++;d++;*/return a + b + c + d;};func5();// 局部的静态和全局变量不能捕捉，也不需要捕捉static int m = 0;return 0;
}

注意：只能捕捉定义在lambda的前面的变量，不能捕捉定义在后面的变量！！

代码示例：

int a = 0;
auto fun9 = [&, a]
{y++;//错误
};int y = 9;

注意：一般值捕捉是不能改变，但是加上关键字 mutable 就不一样了！

代码示例：

int a = 0;
auto fun9 = [&, a]()mutable
{a++;
};

3）lambda的应用

        在学习 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 mian()
{vector<Goods> v = { { "苹果", 2.1, 5 }, { "⾹蕉", 3, 4 }, { "橙⼦", 2.2, 3
}, { "菠萝", 1.5, 4 } };// 类似这样的场景，我们实现仿函数对象或者函数指针⽀持商品中// 不同项的⽐较，相对还是⽐较⿇烦的，那么这⾥lambda就很好⽤了sort(v.begin(), v.end(), ComparePriceLess());sort(v.begin(), v.end(), ComparePriceGreater());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;
}

4）lambda的原理

        lambda 的原理和范围 for 很像，编译后从汇编指令层的角度看，压根就没有 lambda 和范围for 这样的东西。范围 for 底层是迭代器，而l ambda 底层是仿函数对象，也就说我们写了一个lambda 以后，编译器会生成一个对应的仿函数的类(类里面包含UUID)。

UUID解析：

        仿函数的类名是编译按一定规则（UUID）生成的，保证不同的 lambda 生成的类名不同，lambda参数/返回类型/函数体就是仿函数 operator() 的参数/返回类型/函数体，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.49;// lambdaauto r2 = [rate](double money, int year) {return money * rate * year;};// 函数对象Rate r1(rate);r1(10000, 2);r2(10000, 2);auto func1 = [] {cout << "hello world" << endl;};func1();return 0;
}

汇编代码示例：

	Rate r1(rate);
00007FF640F725E9  movsd       xmm1,mmword ptr [rate]  
00007FF640F725EE  lea         rcx,[r1]  
00007FF640F725F2  call        Rate::Rate (07FF640F710F0h)  
00007FF640F725F7  nop  r1(10000, 2);
00007FF640F725F8  mov         r8d,2  
00007FF640F725FE  movsd       xmm1,mmword ptr [__real@40c3880000000000 (07FF640F7BDB8h)]  
00007FF640F72606  lea         rcx,[r1]  
00007FF640F7260A  call        Rate::operator() (07FF640F71172h)  
00007FF640F7260F  nop  r2(10000, 2);
00007FF640F72610  mov         r8d,2  
00007FF640F72616  movsd       xmm1,mmword ptr [__real@40c3880000000000 (07FF640F7BDB8h)]  
00007FF640F7261E  lea         rcx,[r2]  
00007FF640F72622  call        `main'::`2'::<lambda_1>::operator() (07FF640F72340h)  
00007FF640F72627  nop 

七、包装器

1）function

         std:：function是一个类模板，也是一个包装器。std:：function的实例对象可以包装存储其他的可以调用对象，包括函数指针、仿函数、lambda、bind表达式等，存储的可调用对象被称为|std:：function的目标。若|std :：function 不含目标，则称它为空。调用空std::function 的目标导致抛出std::bad_function_call异常。

        以上是 function 的原型，他被定义<functional>头文件中。std::function-cppreference.com是function的官方文件链接。

        函数指针、仿函数、lambda等可调用对象的类型各不相同，std::function 的优势就是统一类型，对他们都可以进行包装，这样在很多地方就方便声明可调用对象的类型，下面的第二个代码样例展示了std:：function 作为map的参数，实现字符串和可调用对象的映射表功能。

代码示例1：

#include<functional>
int f(int a, int b)
{return a + b;
}struct Functor
{
public:int operator() (int a, int b){return a + b;}
};int mian()
{function<int(int, int)> f1(f);function<int(int, int)> f2(Functor());auto lf2 = [](int a, int b) {return a + b * 100; };vector<function<int(int, int)>> funv = { f,Functor(),lf2};for (auto f : funv){cout << f(1, 3) << endl;}return 0;
}

代码示例2：

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 mian()
{// 包装静态成员函数// 成员函数要指定类域并且前⾯加&才能获取地址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;
}

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 也在<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为第二个参数,以此类推。_1/_2/_3.……这些占位符放到placeholders的一个命名空间中。

代码示例1：

#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;
}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;return 0;
}

代码示例2：

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

完！！！