原文地址:点击打开链接
所谓重载,就是重新赋予新的含义,函数重载就是对一个已有的函数赋予新的含义,使之实现新功能。
运算符的重载主要存在两种形式,一种是作为类的成员函数进行使用,另一种则是作为类的友元函数进行使用。运算符的重载的形式为:返回类型 operator 运算符符号(参数说明)
{
//函数体的内部实现
}
例如,能否用“+”号进行两个复数的相加,在C++中不能在程序中直接用运算符“+”对复数进行相加运算,用户必须自己设法实现复数相加。例如用户可以通过定义一个专门的函数来实现复数相加。
/*
实现复数类中的运算符重载
定义一个复数类重载运算符+、-、*、/,使之能用于复数的加减乘除。
方案一:使用类的成员函数完成运算符的重载;
*/
#include<iostream>
using namespace std;
class Complex
{
private:
double real;
double imag;
public:
Complex()
{
real = 0 ; imag = 0 ;
}
Complex(double r,double i)
{
real = r ; imag = i ;
}
Complex operator+(Complex &c2);
Complex operator-(Complex &c2);
Complex operator*(Complex &c2);
Complex operator/(Complex &c2);
void display();
};
//下面定义成员函数
Complex Complex::operator+(Complex &c2) //定义重载运算符”+“的函数
{
return Complex(this->real+c2.real , this->imag+c2.imag); //此处this->real就是c1.real
}
Complex Complex::operator-(Complex &c2)//定义重载运算符”-“的函数
{
return Complex(this->real-c2.real , this->imag-c2.imag); //此处this->real就是c1.real
}
Complex Complex::operator*(Complex &c2)
{
return Complex(this->real*c2.real , this->imag*c2.imag); //此处this->real就是c1.real
}
Complex Complex::operator/(Complex &c2)
{
Complex c;
c.real = (real*c2.real + imag*c2.imag)/(c2.real*c2.real+c2.imag*c2.imag);
c.imag = (-real*c2.imag + imag*c2.real)/(c2.real*c2.real+c2.imag*c2.imag);
return c;
}
void Complex::display()
{
cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
int main(void)
{
Complex c1(3,4),c2(5,-10),c3;
cout<<"c1=";
c1.display();
cout<<"c2=";
c2.display();
c3=c1+c2; // 此处相当于非重载运算符函数中的“c3=c1.Complex_add(c2)
//将运算符+重载为类的成员函数后,编译系统会将程序中的表达式c1+c2解释为:c1.operator+(c2)即以c2为实参调用c1的运算符重载函数operator+(Complex&c2),operator+是类的一个函数名
cout<<"c1+c2=";
c3.display();
c3=c1-c2;
cout<<"c1-c2=";
c3.display();
c3=c1*c2;
cout<<"c1*c2=";
c3.display();
c3=c1/c2;
cout<<"c1/c2=";
c3.display();
return 0;
}
运算符重载运算符的运算规则
①运算符重载函数也是函数,重载的运算符不会改变运算符的优先级、结合型和参数的个数。
②重载运算符不能违反语言的语法规则。
③赋值运算符除外,重载运算符可由派生类继承下去。
④重载运算符不能使用默认参数。
⑤运算符=、()、[]和->等操作符必须定义为类的成员函数,将这些操作符定义为友元函数将在编译时标记为错误。
⑥C++中不能重载的运算符只有5个:
. (成员访问运算符)
.* (成员指针访问运算符)
∷ (域运算符)
sizeof(长度运算符)
?: (条件运算符)
因为前两个运算符不能重载是为了保证访问成员的功能不能被改变,域运算符和sizeof运算符的运算对象是类型而不是变量或一般表达式,不具重载的特征。
⑦友元运算符的参数规则与类成员运算符的参数规则不同,一员运算符必须显示地声明一个参数,二员运算符必须显示地声明两个参数。类成员运算符重载时,参数中隐含了一个this指针。(另外,C++规定,有的运算符(如赋值运算符、下标运算符、函数调用运算符)必须定义为类的成员函数,有的运算符则不能定义为类的成员函数(如流输入“>>”和流输出“<<”运算符、类型转换运算符))。
重载为类的成员函数时,参数个数=原操作数个数-1(后置++、--除外),它可以通过this指针自由地访问本类的数据成员,可以少写一个函数的参数,但必须要求运算表达式的第一个参数(即运算符左侧的操作数)是一个类对象。
重载为类的友元函数时,参数个数=原操作数个数,且至少应该有一个自定义类型的形参。
//方案二:使用类的友元函数,而不是类的成员函数,完成上面提及的运算符的重载;
#include<iostream>
using namespace std;
class Complex
{
private:
double real;
double imag;
public:
Complex() //定义构造函数
{
real = 0 ; imag = 0 ;
}
Complex(double r,double i) //构造函数重载
{
real = r ; imag = i ;
}
friend Complex operator+(Complex &c1,Complex &c2);
friend Complex operator-(Complex &c1,Complex &c2);
friend Complex operator*(Complex &c1,Complex &c2);
friend Complex operator/(Complex &c1,Complex &c2);
void display();
};
//下面定义友员函数
Complex operator+(Complex &c1,Complex &c2) //定义重载运算符”+“的函数
{
return Complex(c1.real+c2.real,c1.imag+c2.imag);
}
Complex operator-(Complex &c1,Complex &c2) //定义重载运算符”-“的函数
{
return Complex(c1.real-c2.real,c1.imag-c2.imag);
}
Complex operator*(Complex &c1,Complex &c2) //定义重载运算符”*“的函数
{
return Complex (c1.real*c2.real,c1.imag*c2.imag);
}
Complex operator/(Complex &c1,Complex &c2) //定义重载运算符”/“的函数
{
return Complex(c1.real/c2.real,c1.imag/c2.imag);
}
void Complex::display()
{
cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
int main(void)
{
cout<<"用友员函数输出的结果是"<<endl;
Complex c1(3,4),c2(5,-10),c3;
cout<<"c1=";
c1.display();
cout<<"c2=";
c2.display();
c3=c1+c2;
cout<<"c1+c2=";
c3.display();
c3=c1-c2;
cout<<"c1-c2=";
c3.display();
c3=c1*c2;
cout<<"c1*c2=";
c3.display();
c3=c1/c2;
cout<<"c1/c2=";
c3.display();
return 0;
}
如想将一个复数和一个整数相加,如c1+i,可以将运算符重载函数作为成员函数,如下面的形式:
Complex Complex::operator +(int &i) //运算符重载函数作为Complex类的成员函数
{
return Complex(real + i , imag);
}
注意在表达式中重载的运算符“+”左侧应为Complex类的对象,如
c3=c2+i;
不能写成
c3=i+c2; //运算符“+”的左侧不是类对象,编译出错
如果出于某种考虑,要求在使用重载运算符时运算符左侧的操作数是整型量(如表达式i+c2,运算符左侧的操作数i是整数),这时是无法利用前面定义的重载运算符的,因为无法调用i.operator+函数。可想而知,如果运算符左侧的操作数属于C++标准类型(如int)或是一个其他类的对象,则运算符重载函数不能作为成员函数,只能作为非成员函数。如果函数需要访问类的私有成员,则必须声明为友元函数。可以在Complex类中声明:
friend Complex operator+(int &i , Complex &c); //第一个参数可以不是类对象
在类外定义友元函数:
Complex operator+(int &i , Complex &c) //运算符重载函数不是成员函数
{
return Complex(i + c.real , c.imag);
}
将双目运算符重载为友元函数时,在函数的形参表列中必须有两个参数,不能省略,形参的顺序任意,不要求第一个参数必须为类对象。但在使用运算符的表达式中,要求运算符左侧的操作数与函数第一个参数对应,运算符右侧的操作数与函数的第二个参数对应。如
c3 = i + c2; //正确,类型匹配
c3 = c2 + i; //错误,类型不匹配
如何重载增量运算符 ++ 和 --
运算符++和—有前置和后置两种形式,如果不区分前置和后置,则使用operator++( )或operator--( )即可;否则,要使用operator++( )或operator--( )来重载前置运算符,使用operator++(int)或operator--(int)来重载后置运算符,调用时,参数int被传递给值0。如下列程序段:
//重载增量运算符 ++ 和 --
#include<iostream>
using namespace std;
class Complex
{
private:
int x;
int y;
public:
Complex() //定义构造函数
{
x = 0 ; y = 0 ;
}
Complex(int a,int b) //构造函数重载
{
x = a ; y = b ;
}
void display();
Complex operator ++(); //前置自增方式
Complex operator ++(int); //后置自增方式(增加一个int类型的形参)
};
Complex Complex::operator ++()
{
x = x + 1;
y = y + 1;
return *this;
}
Complex Complex::operator ++(int)
{
Complex temp(*this);
x = x + 1;
y = y + 1;
return temp;
}
void Complex::display()
{
cout<<"("<<x<<","<<y<<")"<<endl;
}
int main(void)
{
Complex c1(3,4),c2(5,-10),c3;
c3 = c1++;
cout<<"c1++=";
c3.display();
c3 = ++c2;
cout<<"++c2=";
c3.display();
return 0;
}
重载流输入运算符和流输出运算符
istream 类的对象cin;
ostream类的对象cout;
如果想直接用“<<”和“>>”输出和输入自己声明的类型的数据,必须对它们重载,对“<<”和“>>”重载的函数形式如下:
istream & operator >> (istream &,自定义类 &);
ostream & operator << (ostream &,自定义类 &);
重载运算符“>>”的函数的第一个参数和函数的类型都必须是istream&类型,第二个参数是要进行输入操作的类。
重载“<<”的函数的第一个参数和函数的类型都必须是ostream&类型,第二个参数是要进行输出操作的类。
只能将重载“>>”和“<<”的函数作为友元函数或普通的函数,而不能将它们定义为成员函数。
实现代码如下:
//增加重载流提取运算符“>>”,用“cin>>”输入复数,用“cout<<”输出复数。
#include<iostream>
using namespace std;
class Complex
{
private:
double real;
double imag;
public:
Complex() //定义构造函数
{
real = 0 ; imag = 0 ;
}
Complex(double r,double i) //构造函数重载
{
real = r ; imag = i ;
}
friend istream& operator>>(istream & , Complex & );
friend ostream& operator<<(ostream & , Complex & );
};
//下面定义友员函数
istream& operator>>(istream & in, Complex &c)
{
cout<<"input real part and imaginary part of complex number:";
in>>c.real>>c.imag;
return in;
}
ostream& operator<<(ostream & out, Complex &c)
{
out<<'('<<c.real<<"+"<<c.imag<<"i)";
return out;
}
int main(void)
{
Complex c1 , c2;
cin>>c1>>c2;
cout<<"c1="<<c1<<endl;
cout<<"c2="<<c2<<endl;
return 0;
}