转自：https://www.cnblogs.com/lsgxeva/p/7787500.html
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <vector>
#include <map>
// C++11之前，类模板是支持默认的模板参数，却不支持函数模板的默认模板参数
//1、普通函数带默认参数，c++98 编译通过，c++11 编译通过
void DefParm(int m = 3) {}
//2、类模板是支持默认的模板参数，c++98 编译通过，c++11 编译通过
template <typename T = int>
class DefClass {};
//3、函数模板的默认模板参数， c++98 - 编译失败，c++11 - 编译通过
template <typename T = int>
void DefTempParm() {}
// 类模板的默认模板参数必须从右往左定义，函数模板的默认模板参数则没这个限定
template<class T1, class T2 = int> class DefClass1;
template<class T1 = int, class T2> class DefClass2; // 无法通过编译
template<class T, int i = 0> class DefClass3;
template<int i = 0, class T> class DefClass4; // 无法通过编译
template<class T1 = int, class T2> void DefFunc1(T1 a, T2 b);
template<int i = 0, class T> void DefFunc2(T a);
void mytest()
{
return;
}
int main()
{
mytest();
system("pause");
return 0;
}
===============================================================
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <vector>
#include <map>
// 在C++11之前，类模板和函数模板只能含有固定数量的模板参数。C++11增强了模板功能，允许模板定义中包含0到任意个模板参数，这就是可变参数模板。
// 可变参数模板和普通模板的语义是一样的，只是写法上稍有区别，声明可变参数模板时需要在typename或class后面带上省略号“...”
/*
省略号“...”的作用有两个：
1) 声明一个参数包，这个参数包中可以包含0到任意个模板参数
2) 在模板定义的右边，可以将参数包展开成一个一个独立的参数
*/
template<class ... T>
void func(T ... args) // T叫模板参数包，args叫函数参数包
{//可变参数模板函数
}
func(); // OK：args不含有任何实参
func(1); // OK：args含有一个实参：int
func(2, 1.0); // OK：args含有两个实参int和double
// 一个可变参数模板函数的定义
template<class ... T> void func1(T ... args)
{//可变参数模板函数
//sizeof...（sizeof后面有3个小点）计算变参个数
cout << "num = " << sizeof...(args) << endl;
}
// 通过递归函数展开参数包，需要提供一个参数包展开的函数和一个递归终止函数。
//递归终止函数
void debug()
{
cout << "empty\n";
}
//展开函数
template <class T, class ... Args>
void debug(T first, Args ... last)
{
cout << "parameter " << first << endl;
debug(last...);
}
// 非递归方式展开
template <class T>
void print(T arg)
{
cout << arg << endl;
}
template <class ... Args>
void expand(Args ... args)
{
int a[] = { (print(args), 0)... };
}
void mytest()
{
func1(); // num = 0
func1(1); // num = 1
func1(2, 1.0); // num = 2
debug(1, 2, 3, 4);
/*
运行结果：
parameter 1
parameter 2
parameter 3
parameter 4
empty
*/
expand(1, 2, 3, 4);
return;
}
int main()
{
mytest();
system("pause");
return 0;
}
========================================================================================
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <vector>
#include <map>
// 在C++11之前，类模板和函数模板只能含有固定数量的模板参数。C++11增强了模板功能，允许模板定义中包含0到任意个模板参数，这就是可变参数模板。
// 可变参数模板类 继承方式展开参数包
// 可变参数模板类的展开一般需要定义2 ~ 3个类，包含类声明和特化的模板类
template<typename... A> class BMW{}; // 变长模板的声明
template<typename Head, typename... Tail> // 递归的偏特化定义
class BMW<Head, Tail...> : public BMW<Tail...>
{//当实例化对象时，则会引起基类的递归构造
public:
BMW()
{
printf("type: %s\n", typeid(Head).name());
}
Head head;
};
template<> class BMW<>{}; // 边界条件
// 模板递归和特化方式展开参数包
template <long... nums> struct Multiply;// 变长模板的声明
template <long first, long... last>
struct Multiply<first, last...> // 变长模板类
{
static const long val = first * Multiply<last...>::val;
};
template<>
struct Multiply<> // 边界条件
{
static const long val = 1;
};
void mytest()
{
BMW<int, char, float> car;
/*
运行结果：
type: f
type: c
type: i
*/
std::cout << Multiply<2, 3, 4, 5>::val << std::endl; // 120
return;
}
int main()
{
mytest();
system("pause");
return 0;
}