c++的typename的使用注意点

typename关键字经常出现定义模板类/函数中，但是在实际使用中，除了定义模板中的类型之外在其他代码中也偶尔需要用到typename关键字作为修饰，本文简单概括下常见的情况。

对于常规的定义，如下所示：

template <typename InputIterator,typename OutputIterator,typename ElementType, typename CompType>
OutputIterator filter(InputIterator input_vec_first, InputIterator input_vec_last,
       OutputIterator output_vec_at, const ElementType &value, CompType pred)
{
    InputIterator iter=input_vec_first;
    while((iter=find_if(iter, input_vec_last, bind2nd(pred, value)))!=input_vec_last)
    {
        cout<<"found element:"<<*iter;
        *output_vec_at++=*iter++;
    }
    return output_vec_at;
}

但是如果遇到了一种情况叫做嵌套依赖名字（类型），比如以下情况：

template <typename ElemType>
void print_vector(typename vector<ElemType>::const_iterator vec)
{
    cout<<*vec<<" ";
}

注意函数参数列表中的typename，后面是定义了一个vector<ElemType>类型下的const_iterator，这个迭代器是定义在模板参数类型下的子类型，即嵌套依赖名字（嵌套在依赖于模板参数的名字中），这种情况下，编译器并不确定这个：：后的是一个成员参数还是一个类型，因此我们需要用typename前置修饰来表示该嵌套依赖名字是一个类型。

其实理解了这一点，基本就够了，但是在实际开发中，还有一些特殊情况。

例如下面两种情况是不需要加typename前置修饰的，第一种是在基类列表中，第二种是在成员初始值中。

#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(7); //必须使用  
    }  
};  
      
int main () {  
    Derived<int> d(5);  
      
    return 0;  
}

输出为：

Number = 5  
Number = 7

注意

1.其中Derived继承于Base类中的Nested类，因此此时Nested类是嵌套在依赖于模板参数T的基类Base类中的，但是这是在基类列表中，所以不需要加typename；

2.在对Derived构造函数声明时，Nested类是嵌套依赖名字，但是此时是在对Derived中的Nested这个成员进行初始化操作，所以不需要加typename；

3. 在typename Base<T>::Nested temp(7);中，此时是普通的嵌套依赖名字情况，因此需要加typename表示是类型。

另外当使用特性类(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, 5> ai = {1,2,3,4,5};  
    std::array<int, 5>::iterator aiIter = ai.begin();  
    workWithIter(aiIter);  
    return 0;  
}

另外在定义模板函数/类时，还有一个额外的知识点，就是<>的使用，

对于模板类，必须用上<>，来说明具体的typename内容，typename本身即可以是类型，也可以是常量表达式（函数指针、内置/引用对象等），但定义类时必须A<int>a;这种方式定义。

而对于模板函数，不论是全局还是成员函数，都可以省略<>，只要函数参数列表中的参数类型正确即可。若遇到参数转换可以通过static<Type>(param)来转换为模板中定义的类型。另外特别注意，常量参数只能赋给常量引用。例如：

template <typename T>

void print(const T& e){}

int main()

{

print(1);

}

这种情况下不能漏掉const，因为这里是引用传值，因此可以在函数中改变传入的原始参数，但是原始参数这里是不可变的常量，因此出现矛盾，则需要const对引用修饰。

部分内容参考了 点击打开链接  点击打开链接