面向对象习题DOC.docx

面向对象习题DOC.docx

《面向对象习题DOC.docx》由会员分享，可在线阅读，更多相关《面向对象习题DOC.docx（12页珍藏版）》请在冰豆网上搜索。

面向对象习题DOC

二、定义一个复数类complex，重载运算符+-*/，用于复数的加减乘除运算，将运算符函数重载为complex类

的成员函数，求两个复数的和、差、积、商。

#include

usingnamespacestd;

classcomplex

{

  public:

     complex（intr=0,inti=0）:

real（r）,imag（i）{}

     complexoperator+（complex&）;

     complexoperator-（complex&）;

     complexoperator*（complex&）;

     complexoperator/（complex&）;

     voiddisplay（）

       {

         cout<

       }

  private:

     intreal,imag;

};

complexcomplex:

:

operator+（complex&c2）

{

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

}

complexcomplex:

:

operator-（complex&c2）

{

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

}

complexcomplex:

:

operator*（complex&c2）

{

  returncomplex（real*c2.real,imag*c2.imag）;

}

complexcomplex:

:

operator/（complex&c2）

{

  returncomplex（real/c2.real,imag/c2.imag）;

}

intmain（）

{

  complexc1（12,9）,c2（2,3）,c3;

  cout<<"c1=（";c1.display（）;cout<<"）"<

  cout<<"c2=（";c2.display（）;cout<<"）"<

  c3=c1+c2;

  cout<<"C1+C2=（";c3.display（）;cout<<"）"<

  c3=c1-c2;

  cout<<"c1-c2=（";c3.display（）;cout<<"）"<

  c3=c1*c2;

  cout<<"c1*c2=（";c3.display（）;cout<<"）"<

  c3=c1/c2;

  cout<<"c1/c2=（";c3.display（）;cout<<"）"<

  return0;

}

输出：

c1=（12,9）

c2=（2,3）

C1+C2=（14,12）

c1-c2=（10,6）

c1*c2=（24,27）

c1/c2=（6,3）

Pressanykeytocontinue...

三、定义一个复数类，重载运算符+，用于复数的加法，参加运算的可是类对象，也可以是只有一个整数，

顺序任意，如c1+c2,c1+i,i+c1，设i为整数，编程求两个复数之和，整数和复数之和。

#include

usingnamespacestd;

classcomplex

{

  public:

     complex（）{real=0;imag=0;}

     complex（intr,inti）:

real（r）,imag（i）{}

     complex（intr）{real=r;imag=0;}

     friendcomplexoperator+（constcomplex&,constcomplex&）;

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

  private:

      intreal,imag;

};

complexoperator+（constcomplex&c1,constcomplex&c2）

{

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

}

ostream&operator<<（ostream&output,complex&c）

{

 output<<"（"<

 returnoutput;

}

intmain（）

{

  complexc1（12,9）,c2（2,3）,c3;

  cout<<"c1="<

  cout<<"c2="<

  c3=c1+c2;

  cout<<"c1+c2="<

  c3=c2+c1;

  cout<<"c2+c1="<

  c3=c1+8;

  cout<<"c1+8="<

  c3=8+c1;

  cout<<"8+c1="<

  return0;

}

输出：

c1=（12,9）

c2=（2,3）

c1+c2=（14,12）

c2+c1=（14,12）

c1+8=（20,9）

8+c1=（20,9）

Pressanykeytocontinue...

4.8为复数类（Complex）增加重载的运算符-、-=、*=和/=。

设++为实部和虚部各自增一，亦请重载前置与后置++运算符。

分别使用成员函数和友元函数各做一遍。

并测试。

解：

注意后++，返回的是原值，但实部和虚部已各自增一，所以要先保留原值，再++。

这里是使用成员函数。

#include

usingnamespacestd;

classcomplex{

private:

doublereal;//实部

doubleimag;//虚部

public:

complex（doubler=0.0,doublei=0.0）;//构造函数

voidprint（）;//显示复数

complexoperator+（complexc）;//重载复数"+"

complexoperator-（complexc）;//重载复数"-"

complexoperator*（complexc）;//重载复数"*"

complexoperator/（complexc）;//重载复数"/"

complexoperator+=（complexc）;//重载复数"+="

complexoperator-=（complexc）;//重载复数"-="

complexoperator*=（complexc）;//重载复数"*="

complexoperator/=（complexc）;//重载复数"/="

complexoperator++（）;//重载复数前缀"++"

complexoperator++（int）;//重载复数后缀"++"

};

complex:

:

complex（doubler,doublei）{

real=r;

imag=i;

}

complexcomplex:

:

operator+（complexc）{//重载复数"+"

complextemp;

temp.real=real+c.real;

temp.imag=imag+c.imag;

returntemp;//返回局部变量，函数声明不可为引用，这时返回了局部变量的地址

}

complexcomplex:

:

operator-（complexc）{//重载复数"-"

complextemp;

temp.real=real-c.real;

temp.imag=imag-c.imag;

returntemp;

}

complexcomplex:

:

operator*（complexc）{//重载复数"*"

complextemp;

temp.real=real*c.real-imag*c.imag;

temp.imag=real*c.imag+imag*c.real;

returntemp;

}

complexcomplex:

:

operator/（complexc）{//重载复数"/"

complextemp;

doubled;

d=c.real*c.real+c.imag*c.imag;

temp.real=（real*c.real+imag*c.imag）/d;

temp.imag=（c.real*imag-real*c.imag）/d;

returntemp;

}

complexcomplex:

:

operator+=（complexc）{//重载复数"+="

complextemp;

temp.real=real+c.real;

temp.imag=imag+c.imag;

real=temp.real;

imag=temp.imag;

returntemp;

}

complexcomplex:

:

operator-=（complexc）{//重载复数"-="

complextemp;

temp.real=real-c.real;

temp.imag=imag-c.imag;

real=temp.real;

imag=temp.imag;

returntemp;

}

complexcomplex:

:

operator*=（complexc）{//重载复数"*="

complextemp;

temp.real=real*c.real-imag*c.imag;

temp.imag=real*c.imag+imag*c.real;

real=temp.real;

imag=temp.imag;

returntemp;

}

complexcomplex:

:

operator/=（complexc）{//重载复数"/="

complextemp;

doubled;

d=c.real*c.real+c.imag*c.imag;

temp.real=（real*c.real+imag*c.imag）/d;

temp.imag=（c.real*imag-real*c.imag）/d;

real=temp.real;

imag=temp.imag;

returntemp;

}

complexcomplex:

:

operator++（）{//重载复数前缀"++"

complextemp;

temp.real=++real;

temp.imag=++imag;

returntemp;

}

complexcomplex:

:

operator++（int）{//重载复数后缀"++"

complextemp（real,imag）;

real++;

imag++;

returntemp;

}

voidcomplex:

:

print（）{//显示复数

cout<

if（imag>=0）cout<<'+';

cout<

}

intmain（）{

complexA（30,40）,B（15,30）,C,D;//定义4个复数对象

cout<<"A为:

";A.print（）;

C=A.operator++

（1）;//即C=A++完整的表达式

cout<<"C=A++后，C为：

";C.print（）;

cout<<"A为：

";A.print（）;

C=A.operator++（）;//即++A

cout<<"C=++A后，C为：

";C.print（）;

cout<<"A为：

";A.print（）;

C=A*B;

cout<<"C=A*B后，C为:

";C.print（）;

A*=B;

cout<<"A*=B后，A为:

";A.print（）;

C=A/B;

cout<<"C=A/B后，C为:

";C.print（）;

A/=B;

cout<<"A/=B后，A为:

";A.print（）;

cout<<"B为：

";B.print（）;

D=A+B+C;

cout<<"D=A+B+C后，D为：

";D.print（）;

A+=B+=C;

cout<<"A+=B+=C后，A为：

";A.print（）;

cout<<"B为：

";B.print（）;

D=A-B-C;

cout<<"D=A-B-C后，D为：

";D.print（）;

A-=B+=C;

cout<<"A-=B+=C后，A为：

";A.print（）;

cout<<"B为：

";B.print（）;

A=B;

cout<<"A=B后，A为：

";A.print（）;

D=A*B*C;

cout<<"D=A*B*C后，D为：

";D.print（）;

D=D/B/C;

cout<<"D=D/B/C后，D为：

";D.print（）;

A*=B*=C;

cout<<"A*=B*=C后，A为:

";A.print（）;

A/=B/=C/=C;

cout<<"A/=B/=C/=C后，A为:

";A.print（）;

return0;

}

解2：

#include

classcomplex{

private:

doublereal;//实部

doubleimag;//虚部

public:

complex（doubler=0.0,doublei=0.0）;//构造函数

voidprint（）;//显示复数

friendcomplexoperator+（constcomplex&,constcomplex&）;//重载复数"+"

friendcomplexoperator-（constcomplex&,constcomplex&）;//重载复数"-"

friendcomplexoperator*（constcomplex&,constcomplex&）;//重载复数"*"

friendcomplexoperator/（constcomplex&,constcomplex&）;//重载复数"/"

friendcomplex&operator+=（complex&,constcomplex&）;//重载复数"+="

friendcomplex&operator-=（complex&,constcomplex&）;//重载复数"-="

friendcomplex&operator*=（complex&,constcomplex&）;//重载复数"*="

friendcomplex&operator/=（complex&,constcomplex&）;//重载复数"/="

friendcomplexoperator++（complex&）;//重载复数前缀"++"

friendcomplexoperator++（complex&,int）;//重载复数后缀"++"

};

complex:

:

complex（doubler,doublei）{

real=r;

imag=i;

}

complexoperator+（constcomplex&c1,constcomplex&c2）{//重载复数"+"

complextemp;

temp.real=c1.real+c2.real;

temp.imag=c1.imag+c2.imag;

returntemp;//返回局部变量，函数声明不可为引用，这时返回了局部变量的地址

}

complexoperator-（constcomplex&c1,constcomplex&c2）{//重载复数"-"

complextemp;

temp.real=c1.real-c2.real;

temp.imag=c1.imag-c2.imag;

returntemp;

}

complexoperator*（constcomplex&c1,constcomplex&c2）{//重载复数"*"

complextemp;

temp.real=c1.real*c2.real-c1.imag*c2.imag;

temp.imag=c1.real*c2.imag+c1.imag*c2.real;

returntemp;

}

complexoperator/（constcomplex&c1,constcomplex&c2）{//重载复数"/"

complextemp;

doubled;

d=（c2.real*c2.real+c2.imag*c2.imag）;

temp.real=（c1.real*c2.real+c1.imag*c2.imag）/d;

temp.imag=（c2.real*c1.imag-c1.real*c2.imag）/d;

returntemp;

}

complex&operator+=（complex&c1,constcomplex&c2）{//重载复数"+="

c1.real=c1.real+c2.real;

c1.imag=c1.imag+c2.imag;

returnc1;//返回由引用参数传递过来的变量，函数声明可为引用

}

complex&operator-=（complex&c1,constcomplex&c2）{//重载复数"-="

c1.real=c1.real-c2.real;

c1.imag=c1.imag-c2.imag;

returnc1;

}

complex&operator*=（complex&c1,constcomplex&c2）{//重载复数"*="

complextemp;

temp.real=c1.real*c2.real-c1.imag*c2.imag;

temp.imag=c1.real*c2.imag+c1.imag*c2.real;

c1=temp;

returnc1;

}

complex&operator/=（complex&c1,constcomplex&c2）{//重载复数"/="

complextemp;

doubled;

d=（c2.real*c2.real+c2.imag*c2.imag）;

temp.real=（c1.real*c2.real+c1.imag*c2.imag）/d;

temp.imag=（c2.real*c1.imag-c1.real*c2.imag）/d;

c1=temp;

returnc1;

}

complexoperator++（complex&c）{//重载复数前缀"++"

++c.real;

++c.imag;

returnc;

}

complexoperator++（complex&c,int）{//重载复数后缀"++"

complextemp（c.real,c.imag）;

c.real++;

c.imag++;

returntemp;

}

voidcomplex:

:

print（）{//显示复数

cout<

if（imag>=0）cout<<'+';

cout<

}

intmain（）{

complexA（30,40）,B（15,30）,C,D;//定义4个复数对象

cout<<"A为:

";A.print（）;

C=A.operator++

（1）;//即C=A++完整的表达式

cout<<"C=A++后，C为：

";C.print（）;

cout<<"A为：

";A.print（）;

C=A.operator++（）;//即++A

cout<<"C=++A后，C为：

";C.print（）;

cout<<"A为：

";A.print（）;

C=A*B;

cout<<"C=A*B后，C为:

";C.print（）;

A*=B;

cout<<"A*=B后，A为:

";A.print（）;

C=A/B;

cout<<"C=A/B后，C为:

";C.print（）;

A/=B;

cout<<"A/=B后，A为:

";A.print（）;

cout<<"B为：

";B.print（）;

D=A+B+C;

cout<<"D=A+B+C后，D为：

";D.print（）;

A+=B+=C;

cout<<"A+=B+=C后，A为：

";A.print（）;

cout<<"B为：

";B.print（）;

D=A-B-C;

cout<<"D=A-B-C后，D为：

";D.print（）;

A-=B+=C;

cout<<"A-=B+=C后，A为：

";A.print（）;

cout<<"B为：

";B.print（）;

A=B;

cout<<"A=B后，A为：

";A.print（）;

D=A*B*C;

cout<<"D=A*B*C后，D为：

";D.print（）;

D=D/B/C;

cout<<"D=D/B/C后，D为：

";D.print（）;

A*=B*=C;

cout<<"A*=B*=C后，A为:

";A.print（）;

A/=B/=C/=C;

cout<<"A/=B/=C/=C后，A为:

";A.print（）;

return0;

}