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\n",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