C++ 多态性（3） 运算符重载2

运算符重载的函数一般地采用如下两种形式：成员函数形式和友元函数形式。这两种形式都可访问类中的私有成员。

 

1. 重载为类的成员函数

　　这里先举一个关于给复数运算重载复数的四则运算符的例子。复数由实部和虚部构造，可以定义一个复数类，然后再在类中重载复数四则运算的运算符。先看以下源代码：

#include ＜iostream.h＞ class complex { public: complex() { real=imag=0; } complex(double r, double i) { real = r, imag = i; } complex operator +(const complex &c); complex operator -(const complex &c); complex operator *(const complex &c); complex operator /(const complex &c); friend void print(const complex &c); private: double real, imag; }; inline complex complex::operator +(const complex &c) { return complex(real + c.real, imag + c.imag); } inline complex complex::operator -(const complex &c) { return complex(real - c.real, imag - c.imag); } inline complex complex::operator *(const complex &c) { return complex(real * c.real - imag * c.imag, real * c.imag + imag * c.real); } inline complex complex::operator /(const complex &c) { return complex((real * c.real + imag + c.imag) / (c.real * c.real + c.imag * c.imag), (imag * c.real - real * c.imag) / (c.real * c.real + c.imag * c.imag)); } void print(const complex &c) { if(c.imag＜0) cout＜＜c.real＜＜c.imag＜＜'i'; else cout＜＜c.real＜＜'+'＜＜c.imag＜＜'i'; } void main() { complex c1(2.0, 3.0), c2(4.0, -2.0), c3; c3 = c1 + c2; cout＜＜"/nc1+c2="; print(c3); c3 = c1 - c2; cout＜＜"/nc1-c2="; print(c3); c3 = c1 * c2; cout＜＜"/nc1*c2="; print(c3); c3 = c1 / c2; cout＜＜"/nc1/c2="; print(c3); c3 = (c1+c2) * (c1-c2) * c2/c1; cout＜＜"/n(c1+c2)*(c1-c2)*c2/c1="; print(c3); cout＜＜endl; }  

该程序的运行结果为：

c1+c2=6+1i c1-c2=-2+5i c1*c2=14+8i c1/c2=0.45+0.8i (c1+c2)*(c1-c2)*c2/c1=9.61538+25.2308i   在程序中，类complex定义了4个成员函数作为运算符重载函数。将运算符重载函数说明为类的成员函数格式如下： 　　＜类名＞ operator ＜运算符＞(＜参数表＞) 　　其中，operator是定义运算符重载函数的关键字。 　　程序中出现的表达式： 　　c1+c2 　　编译程序将给解释为： 　　c1.operator+(c2) 　　其中，c1和c2是complex类的对象。operator+()是运算+的重载函数。 　　该运算符重载函数仅有一个参数c2。可见，当重载为成员函数时，双目运算符仅有一个参数。对单目运算符，重载为成员函数时，不能再显式说明参数。重载为成员函数时，总时隐含了一个参数，该参数是this指针。this指针是指向调用该成员函数对象的指针。   　2. 重载为友元函数 　　运算符重载函数还可以为友元函数。当重载友元函数时，将没有隐含的参数this指针。这样，对双目运算符，友元函数有2个参数，对单目运算符，友元函数有一个参数。但是，有些运行符不能重载为友元函数，它们是：=,(),[]和-＞。 　　重载为友元函数的运算符重载函数的定义格式如下： 　　friend ＜类型说明符＞ operator ＜运算符＞(＜参数表＞) 　　{……} 　　下面用友元函数代码成员函数，重载编写上述的例子，程序如下 #include ＜iostream.h＞ class complex { public: complex() { real=imag=0; } complex(double r, double i) { real = r, imag = i; } friend complex operator +(const complex &c1, const complex &c2); friend complex operator -(const complex &c1, const complex &c2); friend complex operator *(const complex &c1, const complex &c2); friend complex operator /(const complex &c1, const complex &c2); friend void print(const complex &c); private: double real, imag; }; complex operator +(const complex &c1, const complex &c2) { return complex(c1.real + c2.real, c1.imag + c2.imag); } complex operator -(const complex &c1, const complex &c2) { return complex(c1.real - c2.real, c1.imag - c2.imag); } complex operator *(const complex &c1, const complex &c2) { return complex(c1.real * c2.real - c1.imag * c2.imag, c1.real * c2.imag + c1.imag * c2.real); } complex operator /(const complex &c1, const complex &c2) { return complex((c1.real * c2.real + c1.imag + c2.imag) / (c2.real * c2.real + c2.imag * c2.imag), (c1.imag * c2.real - c1.real * c2.imag) / (c2.real * c2.real + c2.imag * c2.imag)); } void print(const complex &c) { if(c.imag＜0) cout＜＜c.real＜＜c.imag＜＜'i'; else cout＜＜c.real＜＜'+'＜＜c.imag＜＜'i'; } void main() { complex c1(2.0, 3.0), c2(4.0, -2.0), c3; c3 = c1 + c2; cout＜＜"/nc1+c2="; print(c3); c3 = c1 - c2; cout＜＜"/nc1-c2="; print(c3); c3 = c1 * c2; cout＜＜"/nc1*c2="; print(c3); c3 = c1 / c2; cout＜＜"/nc1/c2="; print(c3); c3 = (c1+c2) * (c1-c2) * c2/c1; cout＜＜"/n(c1+c2)*(c1-c2)*c2/c1="; print(c3); cout＜＜endl; }    该程序的运行结果与上例相同。前面已讲过，对又目运算符，重载为成员函数时，仅一个参数，另一个被隐含；重载为友元函数时，有两个参数，没有隐含参数。因此，程序中出现的 c1+c2 　　编译程序解释为： 　　operator+(c1, c2) 　　调用如下函数，进行求值， 　　complex operator +(const coplex &c1, const complex &c2)   3. 两种重载形式的比较 　　一般说来，单目运算符最好被重载为成员；对双目运算符最好被重载为友元函数，双目运算符重载为友元函数比重载为成员函数更方便此，但是，有的双目运算符还是重载为成员函数为好，例如，赋值运算符。因为，它如果被重载为友元函数，将会出现与赋值语义不一致的地方。 其他运算符的重载举例 　　1).下标运算符重载 　　由于C语言的数组中并没有保存其大小，因此，不能对数组元素进行存取范围的检查，无法保证给数组动态赋值不会越界。利用C++的类可以定义一种更安全、功能强的数组类型。为此，为该类定义重载运算符[]。 　　下面先看看一个例子： #include ＜iostream.h＞ class CharArray { public: CharArray(int l) { Length = l; Buff = new char[Length]; } ~CharArray() { delete Buff; } int GetLength() { return Length; } char & operator [](int i); private: int Length; char * Buff; }; char & CharArray::operator [](int i) { static char ch = 0; if(i＜Length&&i＞=0) return Buff[i]; else { cout＜＜"/nIndex out of range."; return ch; } } void main() { int cnt; CharArray string1(6); char * string2 = "string"; for(cnt=0; cnt＜8; cnt++) string1[cnt] = string2[cnt]; cout＜＜"/n"; for(cnt=0; cnt＜8; cnt++) cout＜＜string1[cnt]; cout＜＜"/n"; cout＜＜string1.GetLength()＜＜endl; }  该数组类的优点如下： 　　(1) 其大小不心是一个常量。 　　(2) 运行时动态指定大小可以不用运算符new和delete。 　　(3) 当使用该类数组作函数参数时，不心分别传递数组变量本身及其大小，因为该对象中已经保存大小。 　　在重载下标运算符函数时应该注意： 　　(1) 该函数只能带一个参数，不可带多个参数。 　　(2) 不得重载为友元函数，必须是非static类的成员函数。 2). 重载增1减1运算符 　　增1减1运算符是单目运算符。它们又有前缀和后缀运算两种。为了区分这两种运算，将后缀运算视为又目运算符。表达式 　　obj++或obj-- 　　被看作为： 　　obj++0或obj--0 　　下面举一例子说明重载增1减1运算符的应用。 #include ＜iostream.h＞ class counter { public: counter() { v=0; } counter operator ++(); counter operator ++(int ); void print() { cout＜＜v＜＜endl; } private: unsigned v; }; counter counter::operator ++() { v++; return *this; } counter counter::operator ++(int) { counter t; t.v = v++; return t; } void main() { counter c; for(int i=0; i＜8; i++) c++; c.print(); for(i=0; i＜8; i++) ++c; c.print(); }    3). 重载函数调用运算符 　　可以将函数调用运算符()看成是下标运算[]的扩展。函数调用运算符可以带0个至多个参数。下面通过一个实例来熟悉函数调用运算符的重载。   #include ＜iostream.h＞ class F { public: double operator ()(double x, double y) const; }; double F::operator ()(double x, double y) const { return (x+5)*y; } void main() { F f; cout＜＜f(1.5, 2.2)＜＜endl; }