C++程序设计-华南理工大学 第9章-运算符重载

第九章运算符重载面向对象程序设计(C++)9.1什么是运算符重载？9.1.1什么是运算符重载？inti=10;i<<2;//这个<<是左移运算符；cout<<“helloworld”;//这个“<<”是什么？9.1.1什么是运算符重载？(续)原型定义(Fromostream.h):inlineostream&ostream::operator<<(constunsignedchar*_s){returnoperator<<((constchar*)_s);}

cout<<“helloworld”;

cout.operator<<(“helloworld”);9.1.1什么是运算符重载？(续)运算符重载:

是一个按特殊格式（operator@）声明的函数，从而改变了内部运算符@的含义。9.2运算符重载的语法9.2.1语法typeclassname::operator@(arg_list)或typeoperator@(arg_list)函数返回值保留字被重载的运算符形式参数函数返回值类名保留字被重载的运算符形式参数classComplex{private:doublerpart;doubleipart;public:Complex(){rpart=ipart=0.0;}

Complex(double

rp,double

ip){

rpart=rp;ipart=ip;}Complexadd(constComplex&com){Complextemp;

temp.rpart=com.rpart+rpart;

temp.ipart=com.ipart+ipart;returntemp;}

};例1：复数相“加”(普通成员函数实现)voidmain(){ComplexC1(2.0,3.0);ComplexC2(5.0,4.0);ComplexC3;C3=C2.add(C1);//要是能写成C3=C1+C2就好了}classComplex{private:doublerpart;doubleipart;public:Complex(){rpart=ipart=0.0;}

Complex(double

rp,double

ip){rpart=rp;ipart=ip;}

ComplexOperator+(constComplex&com){Complextemp;

temp.rpart=com.rpart+rpart;

temp.ipart=com.ipart+ipart;returntemp;}};例2：复数相“加”(特殊成员函数/重载“+”实现)voidmain(){ComplexC1(2.0,3.0);ComplexC2(5.0,4.0);ComplexC3;

C3=C2+C1;}C3=C2+C1;C3=C2.operator+(C1)例3：复数相“加”(重载“+”实现/外部函数)classComplex{private:doublerpart;doubleipart;public:Complex(){

rpart=ipart=0.0;}

Complex(double

rp,double

ip){

rpart=rp;ipart=ip;}

friendComplexOperator+(constComplex&com1,constComplex&com2);};Complexoperator+(constComplex&com1,constComplex&com2){Complextemp;

temp.rpart=com1.rpart+com2.rpart;

temp.ipart=com1.ipart+com2.ipart;returntemp;}

voidmain(){ComplexC1(2.0,3.0);ComplexC2(5.0,4.0);ComplexC3;

C3=C2+C1;}C3=C2+C1C3=Operator+(C2,C1)注意形参跟内部成员函数的区别9.2.2小结1.运算符重载只是一种“语法上的方便”(语法糖)；实质上是另一种函数调用的方式。

C1+C2C1.operator+(C2)2.参数列表中的参数个数取决于：

1)运算符是一元的还是二元的；

2)被定义为全局函数还是成员函数；

C1+C2C1.operator+(C2)C1+C2operator+(C1,C2)

3)对单目后缀运算符，需传递一个int常量(哑元常量值)C1++C1.operator++(1)++C1C1.operator++()9.2.2小结(续)3.运算符重载的限制：

1)不能改变内部算符的优先级、结合顺序及运算符的目数；

C1+C2*C3C1+(C2*C3)C1+C2.operator*(C3)C1.operator+(C2.operator*(C3))

2).,*,::,?:,

sizeof五种运算符不能重载。

3)重载=,[],(),->

都必须是非静态的成员函数，目的是保证它们的第一个操作数是一个自定义对象，从而阻止改变这些运算符作用在基本数据类型上的含义的企图。

a[];//如果调用的是重载的[]，则a一定是自定

//义类型的对象9.2.3例：重载++classinteger{

inti;public:

integer(intii){i=ii;}integeroperator++(){//前缀++i++;return*this;}integeroperator++(int){//后缀++,添加一个哑元

integertemp=*this;i++;returntemp;}}；voidmain(){integera(1),b(2);b=a++;b=++a;}9.3自定义类型转换9.3.1引言问题：如何实现complex+double或double+complex?方法一：内部函数：complexcomplex::operator+(complex);内部函数：complexcomplex::operator+(double);外部函数：complexoperator+(double,complex)方法二：转换构造函数：T->X转换,如：double->Complex

则定义函数：complexcomplex::complex(constdouble);

9.3.2转换构造函数定义double->Complex的转换,实现:double+Complex,Complex+double,Complex+Complex：classComplex{friendint

operator+(constComplex&c1,constComplex&c2);

Complex(constdouble&d){

rpart=d;

ipart=0.0;}…};例：3.0+Complex,将3.0转换成临时的复数对象。9.3.3转换运算符定义转换运算符函数X::operatorT(){//…;}；实现类X->T(通常是内部类型)的转换。Complex->doubledoubleComplex::operatordouble(){returnrpart;}Complexc1(5.5,1.1);doubletemp=1.0;temp=temp+c1;temp=temp+double(c1);9.3.4二义性问题若同时定义了转换运算符合转换构造函数，会引起二义性。classX{

inti;public:friendXoperator+(constX&,constX&);

X(intii){i=ii;}//转换构造函数operatorint(){returni;}//转换运算符};Xoperator+(constX&,constX){returnX(x1.i+x2.i);}voidmain(){Xx1(10);

inti=x1+x2;//二义性i=12+x1;//二义性}9.3.5重载运算符参数匹配规则1.如果正好匹配,则不必进行转换,或者简单的调整(如:数组名转为指针,函数名转为函数指针,类型T转为constT);2.如果不匹配,则试着将char转为int,short转为int,float转为double;3.如果仍不匹配,则进行标准转换(例如,把int

转为double,指向派生类的指针转为指向基类的指针,unsignedint

转为int)4.如果还不匹配,则使用用户定义的转换(包括转换构造函数和转换算符).5.如果不匹配,且函数参数中有…,则用…来匹配任意参数.6.否则,因类型不匹配而出错.注:以上规则适用于所有的重载函数.9.4重要应用举例9.4.1重载赋值运算符classMessage{

char*buffer;

intsize;public:

Message(int

sz=256);

Message(constMessage&msg);Message&operator=(constMessage&msg);

void

setmessage(constchar*buf);

constchar*getmessage()const;

virtual~Message();};Message::Message(int

sz){size=sz; buffer=newchar[size];buffer[0]=‘\0’;}Message::~Message(){

delete[]buffer;}constchar*Message::getmessage()const{

returnbuffer;}void

Message::setmessage(const

char*buf){

strcpy(buffer,buf);}//拷贝构造函数Message::Message(constMessage&msg){size=msg.size; buffer=new

char[size];

strcpy(buffer,msg.buffer);}Message&Message::operator=(constMessage&msg){

if(this!=&msg){

delete[]buffer;size=msg.size; buffer=new

char[size];

strcpy(buffer,msg.buffer); }

return*this;//返回*this的引用目的是实现链式赋值}int

main(int

argc,char*argv[]){Messagemsg(100);

msg.setmessage("IamRick");

cout<<msg.getmessage()<<endl;Messagemsg2(msg);

cout<<msg2.getmessage()<<endl; Messagemsg3; msg3=msg2=msg;//链式赋值

cout<<msg3.getmessage()<<endl;// strcpy(msg.getmessage(),"IamMike");error!!

return0;}Msg3.operator=（msg2.operator=(msg))什么是安全的类?如何设计一个安全的类？一个安全的类，通常须有几个特殊的成员函数：构造函数：正确初始化对象；析构函数：正确回收对象的空间；拷贝构造函数：正确实现用对象去初始化对象；重载赋值运算符：正确实现对象间的赋值。#include<iostream.h>classMyComplex{public: doublerpart; doubleipart; staticintcount;

MyComplex(){

rpart=ipart=0.0;count++;

cout<<"生成对象："<<this<<"初始化构造函数"<<"rpart="<<rpart<<"Count="<<count<<endl;}

MyComplex(MyComplex&h){ ++count;

rpart=h.rpart;

ipart=h.ipart;

cout<<"生成对象："<<this<<"拷贝构造函数"<<"rpart="<<rpart<<"Count="<<count<<endl;} ~MyComplex(){--count;

cout<<"撤消对象："<<this<<"析构函数"<<"rpart="<<rpart<<"Count="<<count<<endl;}

MyComplex

operator+(const

MyComplex&com){

cout<<"进入重载+"<<endl;

MyComplextemp;

temp.rpart=rpart+com.rpart;

temp.ipart=ipart+com.ipart; returntemp;}

MyComplex&operator=(constMyComplex&com){

cout<<"重载赋值运算符"<<endl;

ipart=com.ipart;

rpart=com.rpart; return*this; }

MyComplex(double

rp,doubleip){

cout++;

rpart=rp;

ipart=ip;

cout<<"生成对象："<<this<<"初始化构造函数"<<"rpart="<<rpart<<"count="<<count<<endl;}};int

MyComplex::count=0;int

main(int

argc,char*argv[]){

MyComplexa(1,1),b(2,2),c(3,3),d(4,4);

cout<<"================================"<<endl;

MyComplex&e=c+d;

MyComplexf=d;

MyComplexg;

cout<<"================================"<<endl;g=d; return0;}9.4.2重载[]实现关联数组class

Ctuition{

inttotal[5];public:

Ctuition(){total[0]=5000;//“CS”total[1]=5000;//“EE”…;}voidSetTuition(constchar*dept,intt){

inti;if(dept==“CS”)i=0;elseif(dept==“EE”)i=1;…;

total[i]=t;}

int

GetTuition(constchar*dept){if(dept==“CS”)i=0;