C++双重模板

Template Template Paraments(双重模板参数)

模板参数本身也可以是一个类模板，例如实现一个Stack class。

为了使用其他类型的元素容器，使用者必须两次指定元素类型：一次是元素类型本身，另一次是容器类型：

Stack<int,std::vector> vStack;  //int stack，以vector为容器

如果使用template template parameter,就可以只指明元素类型，无需在指定容器类型：

Stack<int,std::vector> vStack;

为了实现这种特性，你必须把第二个template parameter 声明为template template parameter.

Template<typename T,template<typename ELEM>class CONT = std::deque>

class stack{
Private:
    CONT<T> elems;
Public:
......
};

其默认值则由std::deque 变更为std::deque。这个参数必须是class template，并以第一参数类型完成实例化:

CONT<T> elems;

实际运用时可以使用class template内的任何类型来实例化一个template template parameter。

通常情况下，可以将class关键字改为typename来声明一个template parameter；但是 CONT定义的是一个class类型，因此必须使用关键字class来声明它。

所以,以下为正确代码：

Template<typename T,template<typename ELEM>class CONT = std::deque>      //ok

class Stack{};

而下面的代码则是错误的：

Template<typename T,template<typename ELEM>class CONT = std::deque>      //ok
class Stack{};

所有成员函数也必须按此规则修改：必须指定其第二个template paarmeter为template template parameter。同样的规则也适用成员函数的实现部分。

注意：模板函数不允许拥有template template parameters。

以下是完整代码：

#include<iostream>
#include<string>
#include<deque>
#include<stdexcept>
#include<memory>
#include<cstdlib>
#include<vector>

using namespace std;

template<typename T,template<typename ELEM,typename = std::allocator<ELEM> > class CONT = std::deque >
class Stack
{
private:
CONT<T> elems;
public:
void push(T const&);
void pop();
T top()const;
bool empty()const
{
    return elems.empty();
}

template<typename T2,template<typename ELEM2,typename = std::allocator<ELEM2> >class CONT2>
Stack<T, CONT>& operator=(Stack<T2, CONT2> const&);
};

template<typename T,template<typename,typename> class CONT>
void Stack<T, CONT>::push(T const& elem)
{
    elems.push_back(elem);
}

template<typename T,template<typename,typename> class CONT>
void Stack<T, CONT>::pop()
{
    if (elems.empty())
    {
        throw std::out_of_range("Stack<>::pop():empty stack");
    }
    elems.pop_back();
}

template<typename T,template<typename,typename>class CONT>
T Stack<T, CONT>::top()const
{
    if (elems.empty())
    {
        throw std::out_of_range("Stack<>::top():empty stack");
    }
    return elems.back();
}

template<typename T,template<typename,typename>class CONT>
template<typename T2,template<typename,typename>class CONT2>
Stack<T, CONT>&
Stack<T, CONT>::operator=(Stack<T2, CONT2> const& op2)
{
    if ((void*)this == (void*)&op2)
    {
        return *this;
    }
    Stack<T2, CONT2> tmp(op2);
    elems.clear();
    while (!tmp.empty())
    {
        elems.push_front(tmp.top());
        tmp.pop();
    }
    return *this;
}
int main()
{
    try{
        Stack<int>  intStack;
        Stack<float> floatStack;
        intStack.push(42);
        intStack.push(7);
        floatStack.push(7.7);
        floatStack = intStack;
        cout << floatStack.top() << endl;
        floatStack.pop();
        cout << floatStack.top() << endl;
        floatStack.pop();
        cout << floatStack.top() << endl;
    }
    catch (std::exception const& ex)
    {
    cerr << "Exception:" << ex.what() << endl;
    }
    Stack<int, std::vector> vStack;
    vStack.push(42);
    cout << vStack.top()<<endl;
    vStack.pop();
    return 0;
}