计算机二级C 专题 运算符重载.docx

计算机二级C 专题 运算符重载.docx

《计算机二级C 专题 运算符重载.docx》由会员分享，可在线阅读，更多相关《计算机二级C 专题 运算符重载.docx（12页珍藏版）》请在冰豆网上搜索。

计算机二级C专题运算符重载

计算机二级C++专题运算符重载.txt看一个人的的心术，要看他的眼神；看一个人的身价，要看他的对手；看一个人的底牌，要看他的朋友。

明天是世上增值最快的一块土地，因它充满了希望。

二级C++多态性：

运算符重载中的两种形式

1.重载为类的成员函数：

格式：

<类名>operator<运算符>（<参数表>）

例如：

利用重载运算符实现复数类对象的算术四则运算。

#include

classcomplex

{

public:

complex（）{real=imag=0;}

complex（doubler,doubleI）

{

real=r;imag=I;

}

complexoperator+（complex&c）;

complexoperator-（complex&c）;

complexoperator*（complex&c）;

complexoperator/（complex&c）;

friendvoidprint（complex&c）;

private:

doublereal,imag;

};

inlinecomplexcomplex:

:

operator+（complex&c）

{

returncomplex（real+c.real,imag+c.imag）;

}

inlinecomplexcomplex:

:

operator–（complex&c）

{

returncomplex（real-c.real,imag-c.imag）;

}

inlinecomplexcomplex:

:

operator*（complex&c）

{

returncomplex（real*c.real-imag*c.imag,real*c.imag+imag*c.real）;

}

inlinecomplexcomplex:

:

operator/（complex&c）

{

returncomplex（（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））;

}

voidprint（complex&c）

{

if（c.imag<0）

cout<

else

cout<

}

voidmain（）

{

complexc1（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<

｝

说明：

①程序中的表达式：

c1+c2，编译程序将解释c1.operator+（c2）

②当重载成为成员函数时，双目运算符仅有一个参数。

对单目

运算符，重载为成员函数时，总是隐含了一个参数，该参数是this

指针。

This指针指向调用该成员函数对象的指针。

2、重载为友员函数：

当重载友员函数时，将没有隐含的参数this指针。

这样，对双

目运算符，友员函数有２个参数，对单目运算符，友员函数有一个参

数。

格式：

friend<类型说明符>operaotr<运算符>（<参数表>）

{……..}

例如：

重写上例：

#include

classcomplex

{

public:

complex（）{real=imag=0;}

complex（doubler,doubleI）

{

real=r;imag=I;

}

friendcomplexoperator+（complex&c1,complex&c2）;

friendcomplexoperator-（complex&c1,complex&c2）;

friendcomplexoperator*（complex&c1,complex&c2）;

friendcomplexoperator/（complex&c1,complex&c2）;

friendvoidprint（complex&c）;

private:

doublereal,imag;

};

complexoperator+（complex&c1,complex&c2）

{

returncomplex（c1real+c2.real,c1.imag+c2.imag）;

}

complexoperator–（complex&c1,complex&c2）

{

returncomplex（c1.real-c2.real,c1.imag-c2.imag）;

}

complexoperator*（complex&c1,complex&c2）

{

return

complex（c1real*c2.real-c1.imag*c2.imag,c1.real*c2.imag+c1.imag*c2.real）;

}

complexoperator/（complex&c1,complex&c2）

{

return

complex（（c1.real*c2.real+c1.imag*c2.imag）/（c1.real*c2.real+c1.imag*c2.imag）,

（c1.imag*c2.real-c1.real*c2.imag）/（c1.real*c2.real+c1.imag*c2.imag））;

}

voidprint（complex&c）

{

if（c.imag<0）

cout<

else

cout<

}

voidmain（）

{

complexc1（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<

｝

说明：

c1+c2编译程序结实为operator+（c1,c2）,将调用complex

operator+（complex&c1,complex&c2）求值。

同理，c1-c2理解为operator–（c1,c2）,调用complexoperator

–（complex&c1,complex&c2）实现上述表达式的求值。

3、两种重载形式的比较：

一般来说，单目运算符最好被重载为成员函数，对双目运算符最

好被重载为友员函数。

例如：

c+5.67

其中c是complex类的对象，上述表达式表明复数加上一个浮

点数，这是有意义的。

其结果是将浮点数加到复数的实部，虚部不变。

重载为成员函数：

→c.operator+（5.67）

→c.operator+（complex（5.67））

重载为友员：

→operator+（c,5.67）

→operator+（c,complex（5.67））

可行。

再考虑：

5.67+c

重载为友元：

operator+（complex（5.67）,c）

重载为成员函数：

5.67.operator+（c）,j就不对了。

所以，对双目运算符重载为友员函数比重载为成员函数更方便写。

但是有的双目运算符还是重载为成员函数，如赋值运算符。

例如：

将赋值运算符重载为成员函数：

#include

classA

{

public:

A（）{X=Y=0;}

A（intI,intj）{X=I;Y=j;}

A（A&p）

{

X.p.X;Y=p.Y;

}

A&operator=（A&p）;

IntgetX（）{returnX;}

IntgetY（）

{returnY;}

private:

intX,Y;

}

A&A:

:

operator=（A&p）

{

X=p.X;

Y=p.Y;

Cout<<‖ssignmentoperatorcalled.\n‖;

Return*this;

}

voidmain（）

{

Aa（7,8）;

Ab;

B=a;

Cout<

}

执行结果：

Assignmentoperatorcalled.

7,8

说明：

b=a,解释为：

b.operator=（a）,调用：

A&A:

:

operator=（A&p）

例如：

重载增１减１运算符。

Obj++或obj—

#include

classcounter

{

public:

counter（）{v=0;}

counteroperator++（）;

counteroperator++（int）;

voidprint（）{cout<

private:

unsignedv;

};

countercounter:

:

operator++（）

{

v++;

return*this;

}

countercounter:

:

operator++（int）

{

countert;

t.v=v++;

returnt;

}

voidmain（）

{

counterc;

for（intI=0;I<8;I++）

c++;

c.print（）;

for（I=0;I<8;I++）

++c;

c.print（）;

}

执行结果：

８

１６

说明：

重载运算函数counteroperator++（）为前缀运算符；counter

operator++（int）为后缀运算符。

4、插入符（<<）和提取符（>>）的重载。

例如：

重载插入符和提取符对日期进行输出和输入。

#include

classDate

{

public:

Date（inty,intm,intd）

{Year=y;Month=m;Day=d;}

friendostream&operator<<（ostream&stream,Date&date）;

friendistream&operator>>（istream&stream,Date&date）;

private:

intYear,Month,Day;

};

ostream&operator<<（ostream&stream&stream,Date&date）

{

srteam<

returnstream;

}

istream&operator>>（istream&stream,Date&date）

{

stream>>date.Year>>date.Month>>date.Day;

returnstream;

}

voidmain（）

{

DateCdate（1998,8,17）;

Cout<<‖Currentdate:

‖<

Cout<<‖Enternewdate:

‖;

Cin>>Cdate;

Cout<<‖Newdate:

‖<

}

执行：

currentdate:

1998/8/17

Enternewdate:

1998818

Newdate:

1998/8/18

分析：

定义重载插入符时，使用ostream类，因为cout是从该类中

派生出来的。

定义重载提取符时，使用istream类，因为cin是从

该类中派生出来的。

重载的运算符函数说明为类的友员函数，目的

是为访问类中的私有成员。

例如：

对于复数这种数据类型的插入符和提取符进行重载。

#include

classcomplex

{

public:

complex（）{real=imag=0.0;}

complex（doublea,doubleb）

{real=a;imag=b;}

friendcomplexoperator+（complex&c1,complex&c2）;

friendostream&operator<<（ostream&stre,complex&c）;

friendistream&operator>>（istream&stre,complex&c）;

private:

doublereal,imag;

}；

complexoperator+（complex&c1,complex&c2）

{

doubler=c1.real+c2.real;

doubleI=c1.imag+c2.imag;

returncomplex（r,I）;

}

osrteam&operator<<（ostream&stre,complex&c）

{

stre<<‖（―<

returnstre;

}

istream&operator>>（istream&stre,complex&c）

{

stre>>c.real>>c.imag;

returnstre;

}

voidmain（）

{

complexx,y,z;

cout<<‖Inputtwocomplexnumber:

\n‖;

cin>>x>>y;

z=x+y;

cout<

}

执行：

Inputtwocomplexnumber:

592346

（28,55）