effective C++ 条款 42：了解typename的双重意义

template声明式中，class和typename这两个关键字意义彻底相同

template<class T> class Widget;

template<typename T> class Widget;

有时候你必定要用typename，

能够在template中指涉的两种名称：

template <typename C> 
void print2nd(const C& container) 
{ 
    if (container.size() >= 2) 
    { 
        C::const_iterator iter(container.begin()); 
        ++iter; 
        int value = *iter; 
        std::cout << value; 
    } 
}

iter的类型是C::const_iterator 其实是什么必须取决于template参数C。template内出现的名称若是相依于某个template参数，称之为从属名称（dependent names）。若是从属名称在class内呈嵌套状，称之为嵌套从属名称（nested dependent name）。C::const_iterator 就是这样一个名称嵌套从属名称。

value类型int。不依赖任何template参数的名称。称为非从属名称（non-dependent name）。

嵌套从属名称可能致使解析的困难：

template <typename C> 
void print2nd(const C& container) 
{ 
    C::const_iterator* x; 
}

看起来咱们好像声明一个local变量，是个指针，指向一个C::const_iterator。 但它之因此被那么认为，是由于咱们“已经知道”C::const_iterator 是个类型。若是C::const_iterator 不是个类型呢？若是C有个static成员变量碰巧被命名为const_iterator。过期x碰巧是个global变量名称，那样上述代码就是一个相乘动做，C::const_iterator 乘以x。撰写c++解析器的人必须操心全部可能的输入。

在咱们知道C之前，没有任何办法能够知道C::const_iterator 是否为一个类型。而当编译器开始解析template print2nd时，还没有肯定C是什么东西。

c++有个规则能够解析此一歧义状态：若是解析器在template中遭遇一个嵌套从属名称，它便假设这个名称不是个类型，除非你告诉它是。缺省状况下从属名称不是类型。此外还有个例外。

因此上述代码不是有效的c++代码。咱们必须告诉c++说C::const_iterator 是个类型。只要紧邻它以前放置关键字typename便可：

template <typename C>//这个合法的c++代码 
void print2nd(const C& container) 
{ 
    if (container.size() >= 2) 
    { 
        typename C::const_iterator iter(container.begin()); 
        ++iter; 
        int value = *iter; 
        std::cout << value; 
    } 
}

typename只用来验明嵌套从属类型名称；其余名称不应有它存在。

template <typename C> 
void f(const C& container, //不容许使用typename 
       typename C::iterator iter);//必定要使用typename

“typename必须做为嵌套从属类型名称的前缀词”这一规则的例外是，typename不能够出如今base classes list内的嵌套从属类型名称以前，也不可在member initialization list（成员初始化列表）中做为base class修饰符。例如：

template <typename T> 
class Derived: public Base<T>::Nested{//base class list中不容许“typename” 
public: 
    explicit Derived(int x) 
        :Base<T>::Nested(x)//mem.init.list中不容许“typename” 
    { 
       typename Base<T>::Nested temp;//嵌套从属类型既不在base class list中也不在mem.init.list中， 
    }                                                         //做为一个base class修饰符需加上typename 
};

让咱们看一个typename例子：一个function template，他接受一个迭代器，而咱们打算为该迭代器指涉的对象作一份复件temp：

template <typename IterT> 
void workWithIterator(IterT) 
{ 
    typename std::iterator_traits<IterT>::value_type temp(*iter); 
}

这是个标准trait class的一种运用（条款47），至关于说“类型IterT之对象所指之物的类型”。若是IterT是vector<int>::iterator，temp的类型就是int，若是IterT是list<string>::iterator，temp的类型就是string。因为std::iterator_traits<IterT>::value_type是个嵌套从属类型名称（value_type被嵌套于iterator_traits<IterT>以内而IterT是个template参数），因此必须在它以前放置typename。

这么长你确定会想创建一个typedef。对于traits成员名称如value_type，广泛习惯是设定typedef名称用以表明某个traits成员名称：

template <typename IterT> 
void workWithIterator(IterT) 
{ 
    typedef typename std::iterator_traits<IterT>::value_type value_type; 
    value_type temp(*iter); 
}

分类:  c/c++