在泛型编程的形参表中，关键字typename和class具有相同的含义，可以相互使用，两个关键字都可以在同一模板形参表中使用：  

1.  typename用在模板定义里，标明其后的模板参数是类型参数。


1. template<typename T,class U> calc (const T&, const U& );   
2.   
3. // 定义一个返回参数中较大者的通用函数  
4. template <typename T>  
5. const T& max(const T& x, const T& y)  
6. {  
7. < x) {  
8.     return x;  
9.   }  
10.   return y;  
11. }


这种情况下，typename可用另一个的等效关键字class代替，如下片段所示：


1. // 定义一个返回参数中较大者的通用函数  
2. template <class T>  
3. const T& max(const T& x, const T& y)  
4. {  
5. < x) {  
6.     return x;  
7.   }  
8.   return y;  
9. }


   引入这个关键字主要是为了避免class可能给人带来的混淆:

 使用关键字typdef 代替关键字class制定模板类型形参也许更为直观，毕竟，可以使用内置类型（而不仅仅只是类类型）作为实际的类型形参，而且，更清楚地声明后面的名字是一个类型名。关键字typedef作为标准c++的组成部分假如到c++中的，因此旧的程序可能只是用class用来修饰泛型编程的形参类型。

2， 模板中标明“内嵌依赖类型名”：内嵌依赖类型名（nested dependent type name）

   .本来typename的用法就是这么简单, 但是STL源代码中还有typename的一种不常见的用法：

例1：

请看SGI STL里的一个例子， 只是STL中count范型算法的实现：


    1. template <class _InputIter, class _Tp>  
2. typename iterator_traits<_InputIter>::difference_type  
3. count(_InputIter __first, _InputIter __last, const _Tp& __value) {  
4.   __STL_REQUIRES(_InputIter, _InputIterator);  
5. <_InputIter>::value_type,  
6.                  _EqualityComparable);  
7.   __STL_REQUIRES(_Tp, _EqualityComparable);  
8. <_InputIter>::difference_type __n = 0;  
9.   for ( ; __first != __last; ++__first)  
10. __first == __value)  
11.       ++__n;  
12.   return __n;  
13. }


    这里有三个地方用到了typename：返回值、参数、变量定义。分别是： 

    typename iterator_traits<_InputIter>：：difference_type
     typename iterator_traits<_InputIter>：：value_type
     typename iterator_traits<_InputIter>：：difference_type __n = 0；

        difference_type， value_type就是依赖于_InputIter（模板类型参数）的类型名。源码如下： 


    1. template <class _Iterator>  
2. truct iterator_traits {  
3.  typedef typename _Iterator::iterator_category iterator_category;  
4.  typedef typename _Iterator::value_type        value_type;  
5.  typedef typename _Iterator::difference_type   difference_type;  
6.  typedef typename _Iterator::pointer           pointer;  
7.  typedef typename _Iterator::reference         reference;  
8. ;

    内嵌是指定义在类名的定义中的。以上difference_type和value_type都是定义在iterator_traits中的。

        依赖是指依赖于一个模板参数。typename iterator_traits<_InputIter>：：difference_type中difference_type依赖于模板参数_InputIter.

        类型名是指这里最终要指出的是个类型名，而不是变量。例如iterator_traits<_InputIter>：：difference_type完全有可能是类iterator_traits<_InputIter>类里的一个static对

        象。而且当我们这样写的时候，C＋＋默认就是解释为一个变量的。所以，为了和变量区分，必须使用typename告诉编译器。

        那么是不是所有的T：：type_or_variable， 或者tmpl<T>：type_or_variable都需要使用typename呢？不是，有以下两个例外。


    3 例外

        （1）类模板定义中的基类列表。


        例如 



    1. template<class T>  
2. class Derived: public Base<T>::XXX  
3. {  
4. ...  
5. }

       （2）类模板定义中的初始化列表。 



    1. Derived(int x) : Base<T>::xxx(x)  
2. {  
3. ...  
4. }

    为什么这里不需要呢？因为编译器知道这里需要的是类型还是变量，

        （1）基类列表里肯定是类型名，（2）初始化列表里肯定是成员变量名。


    例2：


    在模板定义内部指定类型。如下面代码：

    1. typename<class Parm,class U>  
2. Parm fcn(Parm* array,U value)  
3. {  
4.      Parm::size_type *p;  
5.      //如果Parm::size_type是一个类型，这句话的意思就是声明一个变量  
6.      //如果如果Parm::size_type是一个变量（对象），这句话的意思就是乘法运算  
7. }


    假如像上面的代码一样在模板中使用这种语句，则编译器将无法辨别Parm::size_type是一个变量还是一个类型。所以必须显式的告诉编译器：

    Parm::size_type是一个类型：

       则函数模板变为如下所示：


    1. typename<class Parm,class U>  
2. Parm fcn(Parm* array,U value)  
3. {  
4.     typename Parm::size_type *p;  
5. }