c++11函数模板的默认模板参数 和 可变参数模板函数

转自：https://www.cnblogs.com/lsgxeva/p/7787500.html

#define _CRT_SECURE_NO_WARNINGS

#include
#include
#include
#include

// C++11之前，类模板是支持默认的模板参数，却不支持函数模板的默认模板参数

//1、普通函数带默认参数，c++98 编译通过，c++11 编译通过
void DefParm(int m = 3) {}

//2、类模板是支持默认的模板参数，c++98 编译通过，c++11 编译通过
template
class DefClass {};

//3、函数模板的默认模板参数， c++98 - 编译失败，c++11 - 编译通过
template
void DefTempParm() {}

// 类模板的默认模板参数必须从右往左定义，函数模板的默认模板参数则没这个限定
template class DefClass1;
template class DefClass2;   // 无法通过编译

template class DefClass3;
template class DefClass4;         // 无法通过编译

template void DefFunc1(T1 a, T2 b);
template void DefFunc2(T a);

void mytest()
{

    return;
}

int main()
{
    mytest();

    system("pause");
    return 0;
}

===============================================================

#define _CRT_SECURE_NO_WARNINGS

#include
#include
#include
#include

// 在C++11之前，类模板和函数模板只能含有固定数量的模板参数。C++11增强了模板功能，允许模板定义中包含0到任意个模板参数，这就是可变参数模板。

// 可变参数模板和普通模板的语义是一样的，只是写法上稍有区别，声明可变参数模板时需要在typename或class后面带上省略号“...”
/*
省略号“...”的作用有两个：
    1)    声明一个参数包，这个参数包中可以包含0到任意个模板参数
    2)    在模板定义的右边，可以将参数包展开成一个一个独立的参数
*/
template
void func(T ... args) // T叫模板参数包，args叫函数参数包
{//可变参数模板函数

}

func();    // OK：args不含有任何实参
func(1);    // OK：args含有一个实参：int
func(2, 1.0);   // OK：args含有两个实参int和double

// 一个可变参数模板函数的定义
template void func1(T ... args)
{//可变参数模板函数
    //sizeof...（sizeof后面有3个小点）计算变参个数
    cout << "num = " << sizeof...(args) << endl;
}

// 通过递归函数展开参数包，需要提供一个参数包展开的函数和一个递归终止函数。
//递归终止函数
void debug()
{
    cout << "empty\n";
}

//展开函数
template
void debug(T first, Args ... last)
{
    cout << "parameter " << first << endl;
    debug(last...);
}

// 非递归方式展开
template
void print(T arg)
{
    cout << arg << endl;
}

template
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
#include
#include
#include

// 在C++11之前，类模板和函数模板只能含有固定数量的模板参数。C++11增强了模板功能，允许模板定义中包含0到任意个模板参数，这就是可变参数模板。

// 可变参数模板类 继承方式展开参数包
// 可变参数模板类的展开一般需要定义2 ~ 3个类，包含类声明和特化的模板类
template class BMW{};  // 变长模板的声明

template  // 递归的偏特化定义
class BMW : public BMW
{//当实例化对象时，则会引起基类的递归构造
public:
    BMW()
    {
        printf("type: %s\n", typeid(Head).name());
    }

    Head head;
};

template<> class BMW<>{};  // 边界条件

// 模板递归和特化方式展开参数包
template struct Multiply;// 变长模板的声明

template
struct Multiply // 变长模板类
{
    static const long val = first * Multiply::val;
};

template<>
struct Multiply<> // 边界条件
{
    static const long val = 1;
};

void mytest()
{
    BMW 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;
}

/

变长模板参数的其他应用：

#include 
#include 
#include 

template
using VT = std::vector;

template
using store = std::tuple...>;

int main()
{
	store<> a;
	store b;
	store c{ {1,3,5}, {2.0, 4.0, 5.0} };

	VT vi{ 100,200,300 };
	for (const auto& item : vi)
	{
		std::cout << item << std::endl;
	}
	std::cout << std::endl;
	return 0;
}

结果如下：