typename

typename

一些关键概念：

限定名：限定了命名空间的名称。

std::cout; //std就是一个命名空间R

依赖名和非依赖名
依赖名是指依赖于模板参数的名称，而非依赖名则相反，指不依赖于模板参数的名称。

template<class T>
class Myclass
{
	int i;
	vector<int> vi;
	vector<int>::iterator vitr;  //非依赖名
	T t;
	vector<T> vt;
	vector<T>::iterator viter;  //依赖名
	//依赖于模板参数的名称就是依赖名
}

类作用域
在类外部访问类中的名字时，可以使用类作用域符，形如class::name的调用通常有三种：静态数据成员、静态成员函数和嵌套类型。

struct Myclass
{
static int A;  //静态数据成员
static int B(); //静态函数成员
typedef int C; //嵌套类型
}

---

由来分析

"typename"是一个C++程序设计语言中的关键字。当用于泛型编程时是另一术语"class"的同义词。这个关键字用于指出模板声明（或定义）中的非独立名称（dependent names）是类型名，而非变量名。

我们经常会这么用 typename，这是一项C++编程语言的泛型编程（或曰“模板编程”）的功能，typename关键字用于引入一个模板参数。

template <typename T>
const T& max(const T& x, const T& y)
{
  if (y < x) {
    return x;
  }
  return y;
}

在模板定义语法中关键字 class 与 typename 的作用完全一样

template<class T>
const T& max(const T& x, const T& y)
{
  if (y < x) {
    return x;
  }
  return y;
}

• 这里 class 关键字表明T是一个类型，后来为了避免 class 在这两个地方的使用可能给人带来混淆，所以引入了 typename 这个关键字，它的作用同 class 一样表明后面的符号为一个类型。
• 那class使用就够了，为什么又引入了新的关键词 typename ，关于这个问题，Stan Lippman 曾在其博客中表示，最早 Stroustrup 使用 class 来声明模板参数列表中的类型是为了避免增加不必要的关键字；后来委员会认为这样混用可能造成概念上的混淆才加上了typename关键字。
• 而使用 typename 的作用就是告诉 c++ 编译器，typename 后面的字符串为一个类型名称，而不是成员函数或者成员变量，这个时候如果前面没有 typename，编译器没有任何办法知道 T::LengthType 是一个类型还是一个成员名称(静态数据成员或者静态函数)，所以编译不能够通过。

问题浮现

那么问题来了，什么情况下，class定义之后，编译不能通过呢？

template<typename T>
void fun(const T& proto){
 
 
        T::const_iterator it(proto.begin());
}

发生编译错误是因为编译器不知道T::const_iterator是个类型。万一它是个变量呢？ T::const_iterator的解析有着逻辑上的矛盾： 直到确定了T是什么东西，编译器才会知道T::const_iterator是不是一个类型； 然而当模板被解析时，T还是不确定的。这时我们声明它为一个类型才能通过编译：

**而且在模板实例化之前，完全没有办法来区分它们，**这绝对是滋生各种bug的温床。这时C++标准委员会再也忍不住了，与其到实例化时才能知道到底选择哪种方式来解释以上代码，委员会决定引入一个新的关键字，这就是typename。

**千呼万唤始出来，**我们来看看C++标准：

对于用于模板定义的依赖于模板参数的名称，只有在实例化的参数中存在这个类型名，或者这个名称前使用了 typename 关键字来修饰，编译器才会将该名称当成是类型。除了以上这两种情况，绝不会被当成是类型。

因此，如果你想直接告诉编译器 T::const_iterator 是类型而不是变量，只需用 typename修饰：

typename    T::const_iterator it(proto.begin());

这样编译器就可以确定T::const_iterator是一个类型，而不再需要等到实例化时期才能确定，因此消除了前面提到的歧义。

嵌套从属类型

事实上类型T::const_iterator依赖于模板参数T， 模板中依赖于模板参数的名称称为从属名称（dependent name）， 当一个从属名称嵌套在一个类里面时，称为嵌套从属名称（nested dependent name）。 其实T::const_iterator还是一个嵌套从属类型名称（nested dependent type name）。

嵌套从属名称是需要用typename声明的，其他的名称是不可以用typename声明的。比如下面是一个合法的声明：

template<typename T>

void fun(const T& proto ,typename  T::const_iterator it);

总结

typename使用场合

1、在模板定义里表明气候的参数是类型参数

//函数模板

template<typename T, int a, int b>

int funcadd(T c) { };

//类模板
template<typename T, int b>

class myvector {  };

注意这里的typename可以写成class

2、使用类的类型成员，用typename标志这是一个类型。

::作用域运算符 ：1、访问类的静态函数成员 2、访问类型成员myiterator(是一个由typedef定义的类型)

//迭代器
template<typename T>
typename myvector<T>::myiterator myvector<T>::mybegin() 
//这里的typename是必须的，如果不加typename编译器会将myvector<T>::myiterator当成是一个静态数据成员
{
 
}

这里typename是必须的，告诉编译器，这个名字是一个类型，这里的typename不能换成class

template<typename T>
typename T::size_type getlength(const T &c)
{
 
}
 
string::size_type size = getlength(mytest);

当使用类型模板参数 T::类型成员（::类型成员） 时，前面都要加typename·

例子一》》

hpp文件

// myvector.h
#ifndef __MYVECTOR__
#define __MYVECTOR__

template <typename T>
class myvector
{
public:
    typedef T *myiterator;
    // 模板类中的类类型

public:
    myvector();                            // 构造函数
    myvector &operator=(const myvector &); // 赋值运算符重载。在模板内部不需要提供
                                           // 模板参数

public:
    myiterator mybegin(); //
    myiterator myend();   //

public:
    void myfunc();
};

template <typename T> // 类模板函数外部实现
void myvector<T>::myfunc()
{
    return;
}

template <typename T>
myvector<T> &myvector<T>::operator=(const myvector &) // 第一个<T>表示返回的是一
                                                      // 个实例化了的myvector
{
    return *this;
}
//重点是下面这部分
// 类外定义起始迭代器
/*
template <typename T>
myvector<T>::myiterator myvector<T>::mybegin()
{
    cout << "定义部分" << endl;
}
*/

// #endifneed 'typename' before 'myvector<T>::myiterator' because 'myvector<T>' is a dependent scope
// myiteraton是嵌套依赖类型名

template <typename T>
typename myvector<T>::myiterator myvector<T>::mybegin()
{
    cout << "定义部分" << endl;
}

template <typename T>
typename myvector<T>::myiterator myvector<T>::myend()
{
    cout << "定义部分" << endl;
}

因为不知道 在类还未实例化时， 不知道 myvector<T>::myiterator 到底是 myvector<T> 的成员变量，还是 myvector<T> 的类型成员（typedef T* myiterator ,T*类型的成员），所以必须要加typename ,消除歧义。

例子二 》》

#include <iostream>
#include <string>
using namespace std;
template <typename T>
typename T::size_type get_size(const T &value)   //这里的返回值 T::size_type ,必须用typename 修饰
{
    if (value.size())
    {
        return value.size();
    }
}
int main()
{
    string str = "hello world";
    string::size_type size = get_size(str);
    cout << size << endl;
}

注明： 这里的 string::size_type它是一个无符号类型的值，而且能够存放下任何string对象的大小。另外，string类型的索引也是一个size_type类型的。下标运算符 [ ] 接收的就是string::size_type类型。相当于 unsigned int

这里的返回值 类型T::size_type 的 含义在类型T未确定前不明确, 必须用typename 修饰 ,表明 T::size_type 确实属于类型，而非静态变量。