C++2.0特性之一：变量模板(variable template)

变量模板(variable template)是C++2.0的一个新特性，虽然他功能强大，但是在平时的代码中用得比较少。最近在侯捷老师的视频里学到这个知识点，这里简单说一下。

和C++模板一样，变量模板也有函数模板和类模板，这种情况有非常多相似，就是作用对象不同。

那么变量模板这个“变量”体现在哪里？①参数个数可变  ②参数类型可变

也就是我，我们可以给一个函数传进去一个乱七八糟的的一包东西，这包东西的元素个数和元素类型都是不确定的！这确实是一个激动人心的功能，有时候我们确实需要这一种特性，比如说我们希望设计一个参数个数不定的min/max函数，这时候参数可变就派上用场了。（当然其实只是实现可变参数的同类型函数，initializer_list就足够了但是必须要加上一个花括号

侯捷老师的视频里讲到七个例子，这里选几个来理解

首先是函数模板：

变量模板最简单的用法，我们得思考既然这一包得个数和参数类型都是不确定得，那么我们怎样才能精确地拿出里面的每一个元素呢？这里给出一个解决办法：用递归。我们每一次递归中把一包元素分成一个和另外一包两份，即假设本次这一包是n+1个元素，那么我们处理第一个元素，那么剩下n个元素还没处理，我们就把这n个元素分成两份：1+（n-1）这两份，然后把这两份继续递归下去。那么下一层递归就是处理n-1中的第一个元素再继续递归，最后总有处理完的那一天。

talk is cheap, show me the code，一看代码就容易理解了。

#include<bits/stdc++.h>
using namespace std;

void printX() {
    cout<<"All done"<<endl;
}

template<typename T,typename... Types>
void printX(const T& firstArg,const Types&... args) {
    cout<<firstArg<<endl;
    printX(args...);
}

int main()
{
    printX(7.5,"hello",bitset<16>(377),42);
    return 0;
} 

OK，学懂了上面那个例子，我们也许想用变量模板做一些有趣的小东西，我们可以尝试用变量模板模拟C语言的printf函数。

代码有注释，很好懂。

#include<bits/stdc++.h>
using namespace std;

//这个函数是处理最后没有参数了 
void Myprintf(const char *s) {
    while (*s) {
        if (*s=='%' && *(++s)!='%')        //没有参数却还有%，参数不足 
            throw runtime_error("invalid format string: missing arguments");
        cout<<*s; 
        s++;    
    }
}

//这里是Args还有参数，那么继续做 % 的解析 
template<typename T,typename... Args>
void Myprintf(const char* s,T value,Args... args) {
    while (*s) {
        if ((*s)=='%' && *(++s)!='%') {        //解析到一个%，消耗一个参数 
            cout<<value;
            Myprintf(++s,args...);
            return;
        }
        cout<<*s;    //无关%的字符原样输出 
        s++;
    }
    throw logic_error("extra arguments provided to printf");
}

int main()
{
    Myprintf("%d args first:%d %s %lf
",2,42,"Hello",3.1415926);
    Myprintf("%d args first:%d %s %lf %d",2,42,"Hello",3.1415926);    
    return 0;
}

从这里可以看到，我们依然使用了递归。其实递归和变量模板的搭配将陪伴我们很久。

比如这里就用变量模板函数实现我们一开头所说的：可变参数的max函数：非常简洁小巧

#include<bits/stdc++.h>
using namespace std;

template<typename T>
T maximum(T n) {
    return n;
}

template<typename T,typename... Args>
int maximum(T first,Args... args) {
    return max(first,maximum(args...));
}

int main()
{
    cout<<maximum(12,2,94,41,36,1)<<endl;
    return 0;
} 

上面都是模板函数，现在到模板类。其实道理也一样，都是个数和类型都可变，也都是递归处理：

#include<bits/stdc++.h>
using namespace std;

//下面的两个struct都是模板类，函数里直接创建临时变量调用函数 

//盘点IDX然后输出，然后创建新的struct就行递归 
template<int IDX,int MAX,typename... Args>
struct PRINT_TUPLE {
    static void print(ostream& os,const tuple<Args...>& t) {
        os<<get<IDX>(t)<<(IDX+1==MAX ? "" : ",");
        PRINT_TUPLE<IDX+1,MAX,Args...>::print(os,t);    //注意IDX+1 
    }
};
//什么都不干的PRINT_TUPLE，处理最后 
template<int MAX,typename... Args>
struct PRINT_TUPLE<MAX,MAX,Args...> {
    static void print(ostream& os,const tuple<Args...>& t) {
    }
};

//重载了<<运算符，重点是 PRINT_TUPLE
template<typename... Args>
ostream& operator << (ostream& os,const tuple<Args...>& t) {
    os<<"[";
    PRINT_TUPLE<0,sizeof...(Args),Args...>::print(os,t);
    return os<<"]";
}

int main()
{
    cout<<make_tuple(7.5,string("hello"),42,bitset<16>(377));
    return 0;
}

接下来，我们要用变量模板实现tuple，我们有继承版本和组合版本的，都是令人拍案叫绝的实现。

继承版本的，构造函数把第一个元素(自己的)和后n-1个元素(继承自父类)，这样不断继承不断新增一个元素得到我们想要的个数。

其实原理不难理解，但是代码实现上还是有许多技巧的。

#include<bits/stdc++.h>
using namespace std;

template<typename... Values> class tup;

//最基础的那个基类，就是一个空的类 
template<> 
class tup<> {
};
/*
tup<>
tup<int>
tup<int,double>
tup<int,double,string>
*/ 
template<typename Head,typename... Tail>
//<Head,Tail...>继承自<Tail...> 
class tup<Head,Tail...> : private tup<Tail...> {
private:
    typedef tup<Tail...> inherited;        //父类的类型 
protected:
    Head m_head;
public:
    tup() {}
    //那么构造函数把第一个元素(自己的)和后n-1个元素(继承自父类) 
    tup(Head v,Tail... vtail) : inherited(vtail...),m_head(v) {
    }
    
    Head head() {
        return m_head;
    }
    inherited& tail() {
        return *this;
    }
};

int main()
{
    tup<int,float,string> it1(42,66.3,"world");
    cout<<it1.head()<<endl;
    cout<<it1.tail().head()<<endl;
    cout<<it1.tail().tail().head()<<endl;
    return 0;
}

组合版本的

#include<bits/stdc++.h>
using namespace std;

template<typename... Values> class tup;

//最基础的那个基类，就是一个空的类 
template<> 
class tup<> {
};
/*
tup<>
tup<int>
tup<int,double>
tup<int,double,string>
*/ 
template<typename Head,typename... Tail>
class tup<Head,Tail...> {
private:
    typedef tup<Tail...> composited;
protected:
    composited m_tail;    //注意这里，组合的关键 
    Head m_head;
public:
    tup() {}
    //那么构造函数把第一个元素和后n-1个元素(新组合) 形成组合 
    tup(Head v,Tail... vtail) : m_tail(vtail...),m_head(v) {
    }
    
    Head head() {
        return m_head;
    }
    composited& tail() {
        return m_tail;
    }    
}; 

int main()
{
    tup<int,float,string> it1(41,6.3,"hello");
    cout<<it1.head()<<endl;
    cout<<it1.tail().head()<<endl;
    cout<<it1.tail().tail().head()<<endl;
    return 0;
} 

参考资料：

侯捷老师的C++2.0课程：https://www.bilibili.com/video/BV11x411Z7zk