关于C++模板和重载的小问题

关于C++模板和重载的小问题

前几天和一位朋友讨论了有关C++模板和重载的一个小问题。我记得最初发现问题的代码是这样的：

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

class Node
{
public:
	int m;
	Node(int value) : m(value) {}
	friend ostream& operator<<(ostream& o, const Node*& p);
};

ostream& operator<<(ostream& o, const Node*& p)
{
	o << p->m << endl;
	return o;
}

int main()
{
	Node* p = new Node(10);
	cout << p << endl;

	list<Node*> l;
	l.push_back(p);
	copy(l.begin(), l.end(), ostream_iterator<Node*>(cout, "/n"));
}

上面的代码先用“cout << p”这样的方式显示Node内容，因为前面已经重载了“<<”运算符，显示结果为10，正确。但接下来用copy函数直接把list中的元素“复制”到cout中，以显示Node内容时，程序只显示出了p中存储的内存地址，而非p所指向的Node的内容，这与预期的结果不符合。

我以前没用过ostream_iterator加copy这种直接复制到输出流中的语法（这可以省去自己写循环的麻烦），不是很熟悉其中的机制。一开始，我认为这是因为STL中的copy函数仅是简单地做赋值操作，没有调用重载的operator<<函数，所以没有显示出Node的内容。但很快，那位朋友就指出，虽然copy函数中做的是赋值操作，但ostream_iterator类重载了赋值运算符：

ostream_iterator<_Ty, _Elem, _Traits>& operator=(const _Ty& _Val)
{	// insert value into output stream, followed by delimiter
	*_Myostr << _Val;
	if (_Mydelim != 0)
		*_Myostr << _Mydelim;
	return (*this);
}

这段重载过的代码会调用“<<”运算符函数。也就是说，copy函数没有得到预期结果，这里面一定还有其他我们没有注意到的问题。我仔细想了想，觉得这个问题可以用C++关于模板、重载以及类型隐式转换顺序的语法解释清楚。

首先，对程序的跟踪表明，ostream_iterator的operator=在执行“<<”运算符时，调用的是basic_ostream类中重载的“<<”运算符函数：

_Myt& operator<<(const void *_Val);

这说明，C++编译器在选择参数类型以确定调用哪个重载函数时，选择了const void*，而非我们自己定义的const Node*&。这时我注意到，定义我们自己的operator<<函数时，参数p既然已经是const Node*了，就没必要再加&修饰符了，最简洁的定义方式应该是：

friend ostream& operator<<(ostream& o, const Node* p);

果然，把前面的代码改成纯指针的定义后，copy函数也正确地显示了数字10，这是我们期望的结果，说明copy函数这回正确调用了我们重载的“<<”运算符。可为什么简单的增加一个“&”会让C++编译器调用另一个重载函数呢？

我做了个简单的实验：

void foo(const int*& p)
{
	cout << "A" << endl;
}

void foo(const int* p)
{
	cout << "B" << endl;
}

int main()
{
	int i = 10;
	int* p = &i;
	foo(p);
}

这段代码的运行结果是A，这说明，当实参类型是指针时，C++编译器会优先匹配那个带&修饰符（即参数为引用类型）的重载函数。这不是和上面的情况正好相反吗？传给copy函数的list里存储的是Node*，basic_ostream类中重载的“<<”参数类型为const void*，而我们原先重载的参数类型为const Node*&，为什么这一回编译器就不调用我们重载的函数呢？这是不是说明Node*经过copy函数内的几次转换后，类型已经不是Node*了呢？

果然，跟踪一下程序的运行过程就会发现，当copy调用ostream_iterator重载的operator=函数时，实参类型是Node*，而operator=函数的形式参数类型是const _Ty&：

ostream_iterator<_Ty, _Elem, _Traits>& operator=(const _Ty& _Val)

这里，_Ty是模板参数，实际就是我们在copy函数里注明的Node*，而组合到const _Ty&中，参数的类型就变成了：

Node* const &

上面这个变化可以从VC.NET的调试器中看到。这说明ostream_iterator重载的operator=函数已经把实参的类型改成了另一种样子（已经不是单纯的指针了），接下来调用“<<”时，编译器就会选择const void*这样的匹配，而非const Node*&。

是不是越说越乱了。还是从头把思路整理一遍吧：

第一、对于下面这样的模板函数：

template<class T> void foo(const T val);

当T表示的类型是指针如int*时，const和T的结合体是int* const，而非字面上看到的const int*，这可以用下面的代码来证明：

template<class T> void foo(const T val) {}

int main()
{
	int i;
	
	const int* p = &i; 
	foo<int*>(p);	// 编译出错
	
	int* const q = &i;
	foo<int*>(q);	// 可以正确编译运行
}

在C++中，int* const和const int*是完全不同的两种类型，前者const是修饰指针，后者const是修饰指针所指向的值。

第二、对于这样的一组重载函数：

void foo(const int* p);
void foo(int* const p);

当我们用int* const型的指针作为实参调用时，编译器会选择第2个函数，因为第2个函数的参数类型和实参类型完全相同。但对于这样一组重载函数：

void foo(const int* p);
void foo(const int*& p);

当我们同样用int* const型的指针作为实参调用时，编译器会选择第1个函数，因为两个函数参数类型和实参类型都不同，编译器会调用最接近的那个类型（参数的隐式转换匹配顺序，可以参考C++标准中的相关说明）。

这实际就是我们上面遇到的那个问题的答案。basic_ostream类中重载的“<<”参数类型为const void*，我们原先重载的参数类型为const Node*&，而ostream_iterator重载的operator=函数在调用“<<”运算符时，实参类型已经被改成了Node* const &，因此，编译器调用的是ostream_iterator重载的函数，而非我们重载的函数。

所以，当我们把最上面那段程序的“<<”修改为

friend ostream& operator<<(ostream& o, const Node* p);

时，程序可以给出正确的结果。但根据上面的讨论，如果我们把该函数的定义改成：

friend ostream& operator<<(ostream& o, Node* const & p);

程序也可以给出正确的结果。

这只是个小问题，而且是那位朋友编程时偶然遇到的，不过这个问题说明，在C++语言里，参数的定义、隐式转换以及匹配顺序相当重要也相当复杂（C++标准文档里关于这个东西的说明有好长一段），我就很容易在这些地方犯糊涂。

另外，上面的实验都是在VS.NET的C++编译器中做的。那位朋友也在VC6下做了相同的实验，但结果却完全不同。例如，最上面那段程序在VC6下，无论参数类型是指针还是引用，都无法得到正确的结果；奇怪的是，在VC6下，当参数类型是指针时，如果把Node类和“<<”函数的的定义都统统放进std namespace中，居然就可以得到正确结果了。这似乎说明，VC6中的C++编译器在参数匹配顺序方面，并不完全符合C++ 1998标准的定义（也许VC6会优先匹配同一个namespace中的重载函数）。