C++运算符重载（二）——使用方法

原文：http://blog.csdn.net/linlinlinxi007/article/details/5283048

一、运算符重载的两种形式

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

1. 重载为类的成员函数

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

[cpp] view
plaincopy

#include <iostream>

using namespace std;



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) //不申明为内联函数也可以，运算符函数是Complex类的成员函数，可以访问其保护成员变量

{

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'<<endl;

else

cout<<c.real<<'+'<<c.imag<<'i'<<endl;

}



void main()

{

complex c1(2.0, 3.0), c2(4.0, -2.0), c3;

c3 = c1 + c2;

cout<<"c1+c2=";

print(c3);

c3 = c1 - c2;

cout<<"c1-c2=";

print(c3);

c3 = c1 * c2;

cout<<"c1*c2=";

print(c3);

c3 = c1 / c2;

cout<<"c1/c2=";

print(c3);

c3 = (c1+c2) * (c1-c2) * c2/c1;

cout<<"(c1+c2)*(c1-c2)*c2/c1=";

print(c3);

cout<<endl;

}

该程序的运行结果为：


　

2. 重载为友元函数

运算符重载函数还可以为友元函数。当重载为友元函数时，将没有隐含的参数this指针。这样，对双目运算符，友元函数有2个参数，对单目运算符，友元函数有一个参数。但是，有些运行符不能重载为友元函数，它们是：=,(),[]和-＞。

　　重载为友元函数的运算符重载函数的定义格式如下：

　　friend ＜类型说明符＞ operator ＜运算符＞(＜参数表＞)

　　{……}

　　下面用友元函数代码成员函数，重载编写上述的例子，程序如下：

[cpp] view
plaincopy

#include <iostream>

using namespace std;



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);//运算符重载函数申明为友元函数，参数为两个complex类对象

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)//友元函数定义，独立函数，不是complex的成员函数

{

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'<<endl;

else

cout<<c.real<<'+'<<c.imag<<'i'<<endl;

}



void main()

{

complex c1(2.0, 3.0), c2(4.0, -2.0), c3;

c3 = c1 + c2;

cout<<"c1+c2=";

print(c3);

c3 = c1 - c2;

cout<<"c1-c2=";

print(c3);

c3 = c1 * c2;

cout<<"c1*c2=";

print(c3);

c3 = c1 / c2;

cout<<"c1/c2=";

print(c3);

c3 = (c1+c2) * (c1-c2) * c2/c1;

cout<<"(c1+c2)*(c1-c2)*c2/c1=";

print(c3);

cout<<endl;

}

该程序的运行结果与上例相同。

前面已讲过，对双目运算符，重载为成员函数时，仅一个参数，另一个被隐含；重载为友元函数时，有两个参数，没有隐含参数。

因此，程序中出现的 c1+c2

　　编译程序解释为：　　operator+(c1, c2)

　　调用如下函数 complex operator +(const coplex &c1, const complex &c2) 进行求值，

二、 两种重载形式的比较

　　一般说来，单目运算符最好被重载为成员函数；对双目运算符最好被重载为友元函数，双目运算符重载为友元函数比重载为成员函数更方便些，但是，有的双目运算符还是重载为成员函数为好，例如，赋值运算符。因为，它如果被重载为友元函数，将会出现与赋值语义不一致的地方。

三、其他运算符的重载举例

1.下标运算符重载

　　由于C语言的数组中并没有保存其大小，因此，不能对数组元素进行存取范围的检查，无法保证给数组动态赋值不会越界。利用C++的类可以定义一种更安全、功能强的数组类型。为此，为该类定义重载运算符[]。

　　下面先看看一个例子：

[cpp] view
plaincopy

#include <iostream>

using namespace std;



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) //在外部定义类CharArray的成员函数

{

static char ch = 0; //0是字符NULL的ASCII码

if(i<Length&&i>=0) //数组下标边界检查，C++中的数组下标从0开始

return Buff[i]; //返回第i个数组元素的地址

else

{

cout<<"Index out of range."<<endl;

return ch; //返回空指针null

}

}



void main()

{

int cnt;

CharArray string1(6);

char * string2 = "string";

for(cnt=0; cnt<8; cnt++)

string1[cnt] = string2[cnt];

cout<<endl;

for(cnt=0; cnt<8; cnt++)

cout<<string1[cnt];

cout<<endl;

cout<<string1.GetLength()<<endl;

}

运行结果：



该数组类的优点如下：

　　(1) 其大小不必是一个常量。可以先定义一个变量i，然后用CharArray string1(i);定义

　　(2) 运行时动态指定大小可以不用运算符new和delete。

　　(3) 当使用该类数组作函数参数时，不必分别传递数组变量本身及其大小，因为该对象中已经保存大小。

　　在重载下标运算符函数时应该注意：

　　(1) 该函数只能带一个参数，不可带多个参数。

　 (2) 不得重载为友元函数，必须是非static类的成员函数。

2. 重载增1减1运算符

　　增1减1运算符是单目运算符。它们又有前缀和后缀运算两种。为了区分这两种运算，将后缀运算视为双目运算符。表达式

　　obj++或obj--

　　被编译器看作为：

　　obj++0或obj--0

　　下面举一例子说明重载增1减1运算符的应用。

[cpp] view
plaincopy

#include <iostream>

using namespace std;



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(int i=0; i<8; i++)

++c;

c.print();

}

运行结果：

3. 重载函数调用运算符

　　可以将函数调用运算符()看成是下标运算[]的扩展。函数调用运算符可以带0个至多个参数。下面通过一个实例来熟悉函数调用运算符的重载。

[cpp] view
plaincopy

#include <iostream>

using namespace std;



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;

}

运行结果：