标签：
1、当且仅当类模板的参数相同时，你才能对类实体对象相互赋值，即将一个实体对象整体赋值给另外一个实体对象。不能将一种类型的实体对象赋值给另外一种实体对象。如：
Stack<int> intStack1,intStack2;
Stack<double> doubleStack;
intStack1 = intStack2;//OK：两个stack有相同的型别
intStack1 = doubleStack;//ERROR：两个stack没有相同的型别
default assignment需要运算符两边拥有相同的型别。
但是，只要将assignment运算符定义在类中为一个模板，就可以实现不同型别对象的赋值运算。型别不同，但是可以隐式转换。
template<typename T1>
class Stack
{
private:
std::deque<T1> elems;
public:
...
template<typename T2>
Stack<T1> & operator= (Stack<T2> const &);
};
assignment运算符定义如下所示：
template <typename T1>
template <typename T2>
Stack<T1>& Stack<T1>::operator=(stack<T2> const & op2)
{
if((void*)this == (void*)&op2)
{
return *this;
}
Stack<T2> tmp(op2);
elems.clear();
while(!tmp.empty())
{
elems.push_front(tmp.top());
tmp.pop();
}
return *this;
}
2、template template parameter双重模板参数
一个模板参数本身可以类模板。
为了使用其他类型的容器，Stack必须两次指定元素类型：一次是元素类型本身，一次是容器
Stack<int, std::vector<int> > vStack; //int stack,以vector为容器
如果使用双重模板参数，则可以如下定义：只需要指明元素类型，无需指明容器类型
Stack<int, std::vector> vStack;//int stack,以vector为容器
为了实现这种特性，需要将第二个模板参数定义为双重模板参数
template <typename T, template< typename NAME> class cont = std::queue >
class Stack{
private:
cont<T> elems;
...};
和之前的定义差别在于将第二个参数定义为类模板参数：
template< typename NAME> class cont
其默认值为std::queue；这个参数必须是一个类模板，并且由第一个参数完成实体化：cont<T> elems；
本例是用第一个模板参数来实体化第二个模板参数。但是，在实际运用时，可以使用类模板中的任意类型来实体化一个双重模板参数。
普通的模板参数可以用class来代替typename，但是上面的cont不可以用class来代替typename，因为cont是一个类类型，
template <typename T, template< typename NAME> typename cont = std::queue >
class Stack{
private:
cont<T> elems;
...};
由于双重模板参数中的参数并未使用，所以在定义的时候可以讲参数名称去掉：
template <typename T, template< typename > class cont = std::queue >
class Stack{
private:
cont<T> elems;
...};
所有类成员函数定义时，也必须指定其第二个模板参数为双重模板参数：
template <typename T, template< typename > class cont >
void Stack<T,cont>::push(T const &elem)
{
elems.push(elem);
}
函数模板不允许有双重模板参数。
3、如果你直接使用上面的stack声明进行编译，编译器可能会报错：默认值std::queue不符合双重模板参数CONT的要求。问题在于CONT不但必须是个模板，而且其参数必须严格匹配它所替换的双重模板参数的参数。双重模板形参的默认值不会被考虑，因此如果不给出默认值的引数值时，编译器会认为匹配失败。
问题在于标准程序库中的std::queue 模板不只有一个参数。第二个参数是一个配置器allocator，它虽然有预设值，但是当它被用来匹配CONT的参数时，其预设值被编译器强行忽略。
因此，可以从新定义Stack：
template <typename T, template< typename ELEM， typename ALLOC = std::allocator<ELEM> > class cont = std::queue >
class Stack{
private:
cont<T> elems;
...};
即使进行上述修改，VC仍然可能编译错误。可以讲成员elems的定义修改为cont<T,std::allocator<T> > elems;
由于ALLOC实际并未使用，因此也可以讲其省略，stack定义如下：
template <typename T, template< typename ELEM， typename = std::allocator<ELEM> > class cont = std::queue >
class Stack{
private:
cont<T> elems;
public:
void push(T const & );
template <typename T2, template< typename ELEM2， typename = std::allocator<ELEM2> > class cont2 >
Stack<T,cont>& operator=(Stack<T2，cont2> const &);
...};
template <typename , template< typename ， typename > class cont >
void Stack<T, CONT>::push(T const &elem)
{
elems.push(elem);
}
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)
{
...
}
标签：
原文地址：http://www.cnblogs.com/19850928sophiling/p/5338162.html
