原文：http://blog.csdn.net/linlinlinxi007/article/details/5283048
一、运算符重载的两种形式
运算符重载一般采用如下两种形式：成员函数形式和友元函数形式。这两种形式都可访问类中的私有成员。
1. 重载为类的成员函数
这里先举一个关于给复数运算重载复数的四则运算符的例子。复数由实部和虚部构造，可以定义一个复数类，然后再在类中重载复数四则运算的运算符。先看以下源代码：
#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 ＜运算符＞(＜参数表＞)
{……}
下面用友元函数代码成员函数，重载编写上述的例子，程序如下：
#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++的类可以定义一种更安全、功能强的数组类型。为此，为该类定义重载运算符[]。
下面先看看一个例子：
#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运算符的应用。
#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个至多个参数。下面通过一个实例来熟悉函数调用运算符的重载。
#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;
}
运行结果：
扫一扫
3263
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
