一个看起来奇怪的C++程序 && c++操作符重载

这篇随笔源自在coolshell.cn上看到的一篇文章，也第一次看到这样的话，这是linux之父linus说的，在解释他为什么不用C++来写git :  

　　c++ is a horrible language, it is made more horrible by the fact that a lot of substandard programmers use it.

自己看书有很多大神级别的人是这种观点，比如好像the art of unix programming的作者是， 好像很多写程序的高手都认同这样的想法，像云风，coolshell的博主陈皓，陈皓表达了C++是一个不成熟的语言的观点。先不说这个，看一下下面这个程序：

1, 一个看起来奇怪的c++程序

 1 #include <iostream>

 2 #include <vector>

 3 #include <string>

 4 typedef int UINT4;

 5 using namespace std;

 6 class Hack

 7 {

 8 public :

 9         Hack(string name) :name_(name){

10             cout << "Hack constructor : name = " << name_ << endl;    

11         }

12         string name(){

13             return name_;

14         }

15         /*Hack& operator< (Hack& a){

16             cout << name_ << "小于" << a.name() << "(memeber version)" << endl;

17             return *this;

18         }

19         Hack& operator> (Hack& a){

20             cout << name_ << "大于" << a.name() << "(memeber version)" << endl;

21             return *this;

22         }*/

23 private :

24         string name_;

25 };

26 Hack& operator< (Hack &a , Hack &b)

27 {

28         std::cout << a.name() << "小于" << b.name() << endl;

29         return a;

30 }

31 Hack& operator> (Hack &a, Hack &b)

32 {

33         std::cout << a.name() <<  "大于" << b.name() << endl;

34         return a;

35 }

36 int main(int argc, char ** argv)

37 {

38         Hack vector("vector");

39         Hack UINT4("UINT4");

40         Hack foo("foo");

41 

42         vector<UINT4> foo;

43         operator>(operator<(vector, UINT4), foo);

44 //        vector.operator<(UINT4).operator>(foo);

45         return(0);

46 }

让人觉得诡异的是42行， 运行结果是这样的

Hack constructor : name = vector
Hack constructor : name = UINT4
Hack constructor : name = foo
vector小于UINT4
vector大于foo
vector小于UINT4
vector大于foo

事实上当把程序整个看一下之后明白，vector<UINT4> foo;并不是我们第一感觉的那样，当然也不应该这么去写，但是这里只是想说C++可以去这么做到。42行实际上是43行的样子,从运行的结果也可以看出来，怎么解释这个现象呢，现在我只能简单的理解为，编译器在main函数这个域中找到了vector, UINT4,foo的定义，它们都是Hack类的对象，于是就没有再往其它namespace中去寻找了(没有去std::中找vector,也没有在::中找UINT4的typedef定义)， 然后再根据这个语句的结构去找operator<的重载定义，而且operator<的返回结果能够继续下面的调用，就通过了。　　当我把operator>定义(31至34行)改成如下，运行结果没有变化， 当然改operator<就不行了

1 void operator> (Hack &a, Hack &b)

2 {

3          std::cout << a.name() <<  "大于" << b.name() << endl;

4  //      return a; 

5 }

 

2. 比较让我感到奇怪的是，也是要注意的是，当把上面程序的注释拿掉，也就是给operator<, operator>再定义一个member function的版本时，在42行，也就是调用operator<的时候就会出错，给出的信息是 ： 

　　42:10: error: ambiguous overload for ‘operator<’ in ‘vector < UINT4’ 。　

也就是全局和成员的 operator<定义导至了岐义，可以简单理解为编译器为一个operator(至少两元)寻找定义时(当然这时候operator的调用是以纯operator的形式)，会搜寻左操作数类定义的域和全局域，还有所有引入的命名空间的域，若发现有不只一个匹配的，就报错了， 为了测试，我把全局的operator定义放到了 namespace wy下， 并且在main如下修改,在如下的位置加入第2行

1 vector<UINT4> foo;

2 using namespace wy;

3 operator>(operator<(vector, UINT4), foo);

4 vector.operator<(UINT4).operator>(foo);

给出的输出结果是：

vector小于UINT4(memeber version)
vector大于foo(memeber version)
vector小于UINT4
vector大于foo
vector小于UINT4(memeber version)
vector大于foo(memeber version)

如果把 usingnamespace wy;放在第1行之前， 也会报上面的ambiguous的错，可见当使用 vector<UNIT4这样语句时会搜寻所有引的命名空间, 而从下面4行的输出可以看出当把operator重载的形式当全局函数或类的成员函数的形式来直接调用,是可以的,也不会有岐义

 

3. 操作符重载, memebers or namespace functions

上面的例子中其实是把重载的< 和 > 定义为 namespace function的，那到底一般怎么选择，我看了一下thinking in C++和C++ primer中说的，下面这张图摘自 thinking in c++ , 12章

先说说后两行，推荐为member的二元operator,第三行，全是赋值性的。 当然可以看到， < , > 都推荐实现为non-member

第二行的几个operator都必须实现为member,  我自己写测试程序，发现编译器对 =, [ ]的要求是只能带一个参数，可以是任意的， 对->的要求是不能有参数(must be void), operator()我在之前一篇随笔中验证过了，可以任意参数。 对于返回值，都没有要求，但是实现为member的operator的返回都应该是类对象本身的引用，即返回this，因为可以在一个表达式中用多个operator, 下面是在类Hack中加上的，都没有报错

1 void operator->(void){

2 }

3 int operator[](string str){

4 }

5 void operator=(float f){

6 }

 关于friend, 可以把一个函数声明为一个类的friend,  这个函数既可以是member function, 也可以是namespace function, 这样这个函数中就可以直接访问这个类所有对象的private member了， friend最主要的用途是在operator overloading中， 比如我要给Hack类定义operator << 和operator>>， 配合IOStream的输入输出操作对一个类来说是很常用的，当然这不能定义为member了(想想为什么?因为只会去操作符左操作数的类定义中去搜寻相关operator的定义)，在class Hack中如下声明

class Hack{

      friend ostream& operator<<(ostream& os, const Hack& hack);

      friend istream& operator>>(ostream& is, Hack& hack){}

}
ostream& operator<<(ostream& os, const Hack& hack){}

然后再到全局域中去定义，全局域中定义的时候不能加上friend了，friend这个关健词只能出现在class中