template <typename T>
class MyClass {
typename T::SubType * ptr;
…
};
第一个typename我就不多说了，大家都知道，我来说一下第二个。他的意思是说T::SubType是class T内部定义的一个类型，从而ptr是一个指向【T:SubType类型】的指针。
如果在上面的代码中，没有第二个typename关键字的话，编译器会以为SubType是class Type的一个static成员。于是会被编译器理解为一个具体的东西，从而导致T::SubType * ptr 所表达的意思是两个数进行相乘。
关于这个知识的应用比较多的是STL中，比如：
#include <iostream>
// print elements of an STL container
template <typename T>
void printcoll (T const& coll)
{
typename T::const_iterator pos; // iterator to iterate over coll
typename T::const_iterator end(coll.end()); // end position
for (pos=coll.begin(); pos!=end; ++pos) {
std::cout << *pos << ' ';
}
std::cout << std::endl;
}
下面我们来看看另外一个有意思的问题。那就是”.template”,大家仔细查看下面的代码：
template<int N>
void printBitset (std::bitset<N> const& bs)
{
std::cout << bs.template to_string<char,char_traits<char>,
allocator<char> >();
}
大家注意到没有，。这个例子中的“.template”比较怪，但是如果没有他的话，那么编译器无法知道后面的“<”是模板参数的开始。而不是一个小于号。注意，只有当位于 点号之前的物件取决于某一个template parameter的时候，这种情况才会发生，以上的例子中，bs受控于N。也就是显式指明模板函数调用。可以理解为指名点姓的调用模板成员函数而非普通的。
结论是“.template”或者”->template”记号只能在templates中使用。而且他们必须紧跟在于template parameter相关的某个物件。
其实这里关于这个”.template”，笔者也没有搞懂，不知道哪位大牛搞懂了，麻烦指教一下，谢谢了。
下面我们来看看成员模板：
先看看下面的例子：
Stack<int> intStack1, intStack2; // stacks for ints Stack<float> floatStack; // stack for floats … intStack1 = intStack2; // OK: stacks have same type floatStack = intStack1; // ERROR: stacks have different types
默认的赋值运算要求左右两边拥有相等的类型。但是如果把赋值运算定义为一个模板，就可以使得类型不同，但是元素可以隐式转换，比如：
template <typename T>
class Stack {
private:
std::deque<T> elems; // elements
public:
void push(T const&); // push element
void pop(); // pop element
T top() const; // return top element
bool empty() const { // return whether the stack is empty
return elems.empty();
}
// assign stack of elements of type T2
template <typename T2>
Stack<T>& operator= (Stack<T2> const&);
};
我们来实现它看看：关键代码如下：
template <typename T>
template <typename T2>
Stack<T>& Stack<T>::operator= (Stack<T2> const& op2)
{
if ((void*)this == (void*)&op2) { // assignment to itself?
return *this;
}
Stack<T2> tmp(op2); // create a copy of the assigned stack
elems.clear(); // remove existing elements
while (!tmp.empty()) { // copy all elements
elems.push_front(tmp.top());
tmp.pop();
}
return *this;
}
下面我们测试一下啊：
Stack<int> intStack; // stack for ints
Stack<float> floatStack; // stack for floats
…
floatStack = intStack; // OK: stacks have different types,
// but int converts to float
当然这个运算并不改变stack和其元素的类型，赋值完成转换，floatstack返回的任然是float。但是这个技术并不是说任何两个类型都能进行赋值，比如下面的代码就不行：
Stack<std::string> stringStack; // stack of ints Stack<float> floatStack; // stack of floats … floatStack = stringStack; // ERROR: std::string doesn't convert to float
你知道为什么了吗？
当然，和以前一样，你也可以在将内部容器的类型也参数化：
template <typename T, typename CONT = std::deque<T> >
class Stack {
private:
CONT elems; // elements
public:
void push(T const&); // push element
void pop(); // pop element
T top() const; // return top element
bool empty() const { // return whether the stack is empty
return elems.empty();
}
// assign stack of elements of type T2
template <typename T2, typename CONT2>
Stack<T,CONT>& operator= (Stack<T2,CONT2> const&);
};
此时的赋值运算实现代码为：
template <typename T, typename CONT>
template <typename T2, typename CONT2>
Stack<T,CONT>&
Stack<T,CONT>::operator= (Stack<T2,CONT2> const& op2)
{
if ((void*)this == (void*)&op2) { // assignment to itself?
return *this;
}
Stack<T2> tmp(op2); // create a copy of the assigned stack
elems.clear(); // remove existing elements
while (!tmp.empty()) { // copy all elements
elems.push_front(tmp.top());
tmp.pop();
}
return *this;
}
==============================================================================
