C++ 中 typename

声明template参数时, 前缀关键字class和typename可以互换;

使用关键字typename标识嵌套从属类型名称, 但不需在基类列表和成员初始化列表内使用.

从属名称(dependent names): 模板(template)内出现的名称, 相依于某个模板(template)参数, 如T t;

嵌套从属名称(nested dependent names):从属名称在class内呈嵌套装, 如T::const_iterator ci;

非从属名称(non-dependent names): 不依赖任何template参数的名称, 如int value;

如果不特定指出typename, 嵌套从属名称, 有可能产生解析(parse)歧义.

任何时候在模板(template)中指涉一个嵌套从属类型名称, 需要在前一个位置, 添加关键字typename;

否则报错(GCC): error: need 'typename' before 'T::xxx' because 'T' is a dependent scope

#include <iostream>
#include <string>
#include <vector>  

using namespace std;  

template<typename T>
void print2nd(const T& container) {
    typename T::const_iterator iter(container.begin()); //未加typename, 报错
    ++iter;
    int value = *iter;
    std::cout << value;
}  

int main () {
    vector<int> vi = {,,,,};
    print2nd(vi);  

    return ;
}

例外:嵌套从属类型名称, 如果是基类列表(base class list)和成员初值列(member initialization list)中,不使用typename;为什么这里不需要呢？因为编译器知道这里需要的是类型还是变量，（1）基类列表里肯定是类型名，（2）初始化列表里肯定是成员变量名。

#include <iostream>
#include <vector>
using namespace std;  

struct Number {
    Number(int x) {
        std::cout << "Number = " << x << std::endl;
    }
};  

template<typename T>
struct Base{
    typedef Number Nested;
};  

template<typename T>
class Derived: public Base<T>::Nested { //不用typename
public:
    explicit Derived(int x) : Base<T>::Nested(x) { //不用typename
        typename Base<T>::Nested temp(); //必须使用
    }
};  

int main () {
    Derived<int> d();  

    return ;
}

当使用特性类(traits class)时, 必须使用typename, 如

#include <array>
#include <iostream>
using namespace std;  

template<typename T>
void workWithIter(T iter) {
    typedef typename std::iterator_traits<T>::value_type value_type; //使用typename
    value_type temp(*iter);
    std::cout << "temp = " << temp << std::endl;  

}  

int main () {
    std::array<int, > ai = {,,,,};
    std::array<int, >::iterator aiIter = ai.begin();
    workWithIter(aiIter);
    return ;
}

另附：

//下面来讨论typename的第二种用法。现在假设我们有一个类如下：
   template <typename T> class Y
   {
       T::iterator *iter;
       ...
   };
   /* 我们可能本意是想定义一个迭代器对象，例如我们如果用vector<int>来实例化这个模板，那么iter
   则应该是一个迭代器指针，但是，如果我们用下面这个类来实例化这个模板：*/
   class cType
   {
       static int iterator;
       ...
   };
   /* 那么T::iterator *iter会被编译器解释为两个数相乘。事实上，C++编译器会采用第二种解释方法
   ，即使iterator的确是一个类型名。
   为了避免这种矛盾，当我们适用qualified dependent name的时候，需要用typename来指出这是一个
   类型名.即: */
   template <typename T> class Y
   {
       typename T::iterator *iter;
       typedef typename T::iterator iterator; //定义了Y::iterator类型名称
       ...
   };
   //typename 指出下面紧跟着的名称是一个类型