可变参模板template

可变参数模板

原文链接: http://blog.csdn.net/xiaohu2022/article/details/69076281
普通模板只可以采取固定数量的模板参数。然而，有时候我们希望模板可以接收任意数量的模板参数，这个时候可以采用可变参数模板。对于可变参数模板，其将包含至少一个模板参数包，模板参数包是可以接收0个或者多个参数的模板参数。相应地，存在函数参数包，意味着这个函数参数可以接收任意数量的参数。

使用规则

一个可变参数类模板定义如下：

template<typename ... Types>
class Tuple
{};

可以用任意数量的类型来实例化Tuple：

Tuple<> t0;
Tuple<int> t1;
Tuple<int, string> t2;
// Tuple<0> error;  0 is not a type

如果想避免出现用0个模板参数来实例化可变参数模板，可以这样定义模板：

template<typename T, typename ... Types>
class Tuple
{};

此时在实例化时，必须传入至少一个模板参数，否则无法编译。
同样地，可以定义接收任意参数的可变参数函数模板：

template<typename ... Types>
void f(Types ... args);

cout<<sizeof...(args)<<endl;//打印可变参数的个数

// 一些合法的调用
f();
f(1);
f(3.4, "hello");

对于类模板来说，可变模板参数包必须是模板参数列表中的最后一个参数（即模板列表参数中的最后一个参数必须是可变的）。但是对于函数模板来说，则没有这个限制，考虑下面的情况：

template<typename ... Ts, typename U>
class Invalid
{};   // 这是非法的定义，因为永远无法推断出U的类型

template<typename ... Ts, typename U>
void valid(U u, Ts ... args);  // 这是合法的，因为可以推断出U的类型
// void invalid(Ts ... args, U u); // 非法的，永远无法推断出U

valid(1.0, 1, 2, 3); // 此时，U的类型是double，Ts是{int, int, int}

可变参数函数模板实例

无法直接遍历传给可变参数模板的不同参数，但是可以借助递归的方式来使用可变参数模板。可变参数模板允许创建类型安全的可变长度参数列表。下面定义一个可变参数函数模板processValues()，它允许以类型安全的方式接受不同类型的可变数目的参数。函数processValues()会处理可变参数列表中的每个值，对每个参数执行对应版本的handleValue()。

// 处理每个类型的实际函数
void handleValue(int value) { cout << "Integer: " << value << endl; }
void handleValue(double value) { cout << "Double: " << value << endl; }
void handleValue(string value) { cout << "String: " << value << endl; }

// 用于终止迭代的基函数
template<typename T>
void processValues(T arg)
{
    handleValue(arg);
}

// 可变参数函数模板
template<typename T, typename ... Ts>
void processValues(T arg, Ts ... args)
{
    handleValue(arg);
    processValues(args ...); // 解包，然后递归
}

可以看到这个例子用了三次... 运算符，但是有两层不同的含义。用在参数模板列表以及函数参数列表，其表示的是参数包。前面说到，参数包可以接受任意数量的参数。用在函数实际调用中的...运算符，它表示参数包扩展，此时会对args解包，展开各个参数，并用逗号分隔。模板总是至少需要一个参数，通过args...解包可以递归调用processValues()，这样每次调用都会至少用到一个模板参数。对于递归来说，需要终止条件，当解包后的参数只有一个时，调用接收一个参数模板的processValues()函数，从而终止整个递归。

假如对processValues()进行如下调用:

processsValues(1, 2.5, "test");

其产生的递归调用如下：

processsValues(1, 2.5, "test");
    handleValue(1);
    processsValues(2.5, "test");
        handleValue(2.5);
        processsValues("test");
            handleValue("test");

#include <iostream>
#include<string>
#include<string.h>
#include <memory>
using namespace std;
// 用来终止递归并处理包中最后一个元素 
template <typename T>
void print(T t)
{
    cout << t;
}

// 包中除了最后一个元素之外的其他元素都会调用这个版本的print 
template <typename T, typename...Types>
void print(T t, Types ...Arg)
{
    cout << t << endl;   // 打印第一个实参 
    print(Arg...);    // 递归调用，打印其他实参 
}

// 测试 
int main()
{
    print("string1", 2, 3.14f, "string2", 42);
    cout << endl;
    system("pause");
    return 0;
}

类模板的全特化：就是模板中的参数类型都确定了

类模板的偏特化：就是模板中有些参数确定了，有些没有确定

注意：模板的全特化和偏特化都要在类模板的基础上实现

//先定义类模板
  template<typename T1, typename T2>
  class Test
  {
  public:
      Test(T1 i, T2 j) :a(i), b(j) { cout << "模板类" << endl; }
  private:
      T1 a;
      T2 b;
  };
  //模板的全特化
  template<>
  class Test<int, char>
  {
  public:
      Test(int i, char j) :a(i), b(j) { cout << "全特化" << endl; }
  private:
      int a;
      char b;
  };
  //模板的偏特化
  template <typename T2>
  class Test<char, T2>
  {
  public:
      Test(char i, T2 j) :a(i), b(j) { cout << "偏特化" << endl; }
  private:
      char a;
      T2 b;
  };




int main()
{
    string s;
    //调用类模板
    Test<int, int> A(1, 1);
    //模板的全特化
    Test<int, char> B(1, 'c');
    //模板的偏特化
    Test<char, int>  C('c', 1);
    system("pause");
    return 0;
}