c++之typename（同class有what区别）

上篇文章中提到了accelerated c++一个简单的Vec容器。还有两个函数留作练习题11-6：erase和clear。那么怎么来实现呢？实现如下：

// similar to uncreate, but no need to return memory
template <class T> void Vec<T>::clear()
{
	if (data) {
		// destroy (in reverse order) the elements that were constructed
			iterator it = avail;
		while (it != data)
			Vec<T>::alloc.destroy(--it);

	}
	data = avail = limit = 0;
}

// using the keyword typename is critical in defining the following member
// function. The reason is described in p. 141 and p. 153. Without it,g++
// issues "... error: expected constructor, destructor, or type conversion
// before ‘Vec"
template <class T> typename Vec<T>::iterator Vec<T>::erase(iterator it)
{
	if (it != avail) {
		iterator i = it, j = it + 1;
		size_type d = avail - i; // number of element from i to theend
			// move everything behind the object referred by it by one position
			while (j != avail)
				*i++ = *j++;
		avail = i; // when j = avail, i refers the last element (to be erased)
			/*Vec<T>::*/alloc.destroy(i);
		return avail - d - 1; // since it is erased, so one less
	} else
		return avail;
}

template <class T> typename Vec<T>::iterator
Vec<T>::erase(iterator b, iterator e)
{
	if (b != e && e != avail) {
		iterator i = b, j = e;
		size_type span = e - b, behind = avail - e;
		// copy over everything behind the objects referred by b .. e
		while (j != avail)
			*i++ = *j++;
		// destroy (in reverse order) the elements that are left towards the end
			iterator it = avail;
		while (it != i)
			Vec<T>::alloc.destroy(--it);
		avail -= span; // move forward avail span elements forward
			return avail - behind; // point to the element first copied over
	} else
	return erase(b);
}

留意在erase的实现中使用了typename，这个关键词有什么用呢？

template <class T> typename Vec<T>::iterator Vec<T>::erase(iterator it)   

书上如是说：无论何时，如果使用了一个依赖与模板参数的类型时（如vector<T>），而且你想要使用这个类型的成员函数（如size_type）本身就是一个类型，就必须在整个名字前加上typename。

看到这里还是不清楚，那怎么解释呢？以下转自http://blog.csdn.net/myan/article/details/1901

在SGI*STL源代码里, typename这个新的C++关键字得使用可以说是随处可见. 很多以前学习过

C++的人可能还不认识typename, 其实它的常规用法很简单: 在声明模板函数或者模板类时,

传统的写法:

template <class T>

generic_function() {

//........

}

亦可以写成

template <typename T>

------------

generic_func() {

//...............

}

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

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

不了解, 阅读源代码时就会遇到困难. 因为目前我找不到有关这个问题的说明, 所以自己试验了

一下, 得到一个猜测, 现简介如下, 请有识之士斧正.

首先看一段SGI*STL源代码, 摘自stl_iterator.h

1: template <class _Container, class _Iterator>

2: inline insert_iterator<_Container> inserter(_Container& __x, _Iterator __i)

3: {

4: typedef typename _Container::iterator __iter;

5: return insert_iterator<_Container>(__x, __iter(__i));

6: }

令人费解的部分在第四行. 请大家在看我的解释之前先想一想, 我不敢保证下面解释的正确性和

全面性.

解释:

我认为typename的语义是: 通知编译器, 在typename后面被声明的东西是一个类型, 而不是别的

什么东西.

例子:

// tpname.cpp
#include <iostream>
#include <typeinfo> // for typeid() operator

using namespace std;

template <typename TP>
struct COne { // default member is public
typedef TP one_value_type;
};

template <typename COne> // 用一个模板类作为模板参数, 这是很常见的
struct CTwo {
// 请注意以下两行
// typedef COne::one_value_type two_value_type; // *1
typedef typename COne::one_value_type two_value_type; // *2 
};

// 以上两个模板类只是定义了两个内部的public类型, 但请注意第二个类CTwo的two_value_type类型
// 依赖COne的one_value_type, 而后者又取决于COne模板类实例化时传入的参数类型.

int main()
{
typedef COne<int> OneInt_type;
typedef CTwo< OneInt_type > TwoInt_type;
TwoInt_type::two_value_type i;
int j;
if ( typeid(i) == typeid(j) ) // 如果i是int型变量
cout << "Right!" << endl; // 打印Right
return;
}
// ~tpname.cpp

以上例子在Linux下用G++ 2.91编译通过, 结果打印"Right". 但是如果把*1行的注释号去掉, 注释

*2行, 则编译时报错, 编译器不知道COne::one_value_type为何物. 通常在模板类参数中的类型到

实例化之后才会显露真身, 但这个CTwo类偏偏又要依赖一个已经存在的COne模板类, 希望能够预先

保证CTwo::two_value_type与COne::one_value属于同一类型, 这是就只好请typename出山, 告诉

编译器, 后面的COne::one_value_type是一个已经存在于某处的类型的名字(type name), 这样编译

器就可以顺利的工作了.