程序设计教程机械工业出版社课后习题答案第7章操作符重载.docx
《程序设计教程机械工业出版社课后习题答案第7章操作符重载.docx》由会员分享，可在线阅读，更多相关《程序设计教程机械工业出版社课后习题答案第7章操作符重载.docx（43页珍藏版）》请在冰豆网上搜索。
程序设计教程机械工业出版社课后习题答案第7章操作符重载
第7章操作符重载
1、为什么要对操作符进行重载？
是否所有的操作符都可以重载？
答：
通过对C++操作符进行重载，我们可以实现用C++的操作符按照通常的习惯来对某些类（特别是一些数学类）的对象进行操作，从而使得程序更容易理解。
除此之外，操作符重
载机制也提高了C++语言的灵活性和可扩充性，它使得C++操作符除了能对基本数据类型和构造数据类型进行操作外，也能用它们来对类的对象进行操作。
不是所有的操作符都可以重载，因为“.”，“.*”，“:
:
”，“?
:
”，sizeof这五个操作符不能重载。
2、操作符重载的形式有哪两种形式？
这两种形式有什么区别？
答：
一种就是作为成员函数重载操作符；另一种就是作为全局（友元）函数重载操作符。
当操作符作为类的非静态成员函数来重载时，由于成员函数已经有一个隐藏的参数this，因此对于双目操作符重载函数只需要提供一个参数，对于单目操作符重载函数则不需
提供参数。
当操作符作为全局函数来重载时，操作符重载函数的参数类型至少有一个为类、结构、
枚举或它们的引用类型。
而且如果要访问参数类的私有成员，还需要把该函数说明成相应类
的友元。
对于双目操作符重载函数需要两个参数，对于单目操作符重载函数则需要给出一个参数。
操作符=、（）、[]以及->不能作为全局函数来重载。
另外，作为类成员函数来重载时，操作符的第一个操作数必须是类的对象，全局函数重载则否。
3、定义一个时间类Time，通过操作符重载实现：
时间的比较（==、!
=、>、>=、<、<=）、时间增加/减少若干秒（+=、-=）、时间增加/减少一秒（++、--）以及两个时间相差的秒数（-）。
解：
classTime
{
private:
inthour,minute,second;
public:
Time（）
{hour=minute=second=0;
}
Time（inth）
{hour=h;minute=second=0;
}
Time（inth,intm）
{hour=h;
minute=m;
second=0;
}
Time（inth,intm,ints）
{hour=h;
minute=m;
second=s;
}
Time（constTime&t）
{hour=t.hour;
minute=t.minute;
second=t.second;
}
booloperator==（Time&t）
{if（hour==t.hour&&minute==t.minute&&second==t.second）
returntrue;
returnfalse;
}
booloperator!
=（Time&t）
{return!
（*this==t）;
}
booloperator>（Time&t）
{if（hour>t.hour）returntrue;
elseif（hour==t.hour&&minute>t.minute）
returntrue;
elseif（hour==t.hour&&minute==t.minute&&second>t.second）
returntrue;
else
returnfalse;
}
booloperator>=（Time&t）
{return*this>t||*this==t;
}
booloperator<（Time&t）
{return!
（*this>=t）;
}
booloperator<=（Time&t）
{return!
（*this>t）;
}
Time&operator+=（ints）
{second+=s;
while（second>=60）
{second-=60;
minute++;
}
while（minute>=60）
{minute-=60;hour++;
}
while（hour>=24）
hour-=24;
return*this;
}
Time&operator-=（ints）
{second-=s;
while（second<0）
{second+=60;minute--;
}
while（minute<0）
{minute+=60;hour--;
}
while（hour<0）
hour+=24;
return*this;
}
Time&operator++（）//对Timet，操作为：
++t
{*this+=1;return*this;
}
Timeoperator++（int）
//
对Timet
，操作为：
t++
{Timet=*this;
*this+=1;
returnt;
}
Time&operator--（）
{*this-=1;return*this;
}
Timeoperator--（int）
{Timet=*this;*this-=1;
returnt;
}
intoperator-（Time&t）
{//把时间直接换算成秒数计算
intsec1=hour*3600+minute*60+second;
intsec2=t.hour*3600+t.minute*60+t.second;
returnsec2-sec1;
}
};
4、利用操作符重载给出一个完整的复数类的定义。
解：
classComplex
{
private:
doublereal,imag;
public:
Complex（）
{real=imag=0;
}
Complex（doubler）
{real=r;imag=0;
}
Complex（doubler,doublei）
{real=r;imag=i;
}
Complex（constComplex&c）
{real=c.real;
imag=c.imag;
}
doublemodulus（）const
{returnreal*real+imag*imag;
}
Complexoperator-（）const
{Complextemp;temp.real=-real;temp.imag=-imag;
returntemp;
}
friendbooloperator==（constComplex&c1,constComplex&c2）;
friendbooloperator!
=（constComplex&c1,constComplex&c2）;
friendbooloperator>（constComplex&c1,constComplex&c2）;
friendbooloperator>=（constComplex&c1,constComplex&c2）;
friendbooloperator<（constComplex&c1,constComplex&c2）;
friendbooloperator<=（constComplex&c1,constComplex&c2）;
friendComplexoperator+（constComplex&c1,constComplex&c2）;
friendComplexoperator-（constComplex&c1,constComplex&c2）;
friendComplexoperator*（constComplex&c1,constComplex&c2）;
friendComplexoperator/（constComplex&c1,constComplex&c2）;
};
booloperator==（constComplex&c1,constComplex&c2）
{return（c1.real==c2.real）&&（c1.imag==c2.imag）;
}
booloperator!
=（constComplex&c1,constComplex&c2）
{return!
（c1==c2）;
}
booloperator>（constComplex&c1,constComplex&c2）
{returnc1.modulus（）>c2.modulus（）;
}
booloperator>=（constComplex&c1,constComplex&c2）
{returnc1.modulus（）>=c2.modulus（）;
}
booloperator<（constComplex&c1,constComplex&c2）
{returnc1.modulus（）}
booloperator<=（constComplex&c1,constComplex&c2）
{returnc1.modulus（）<=c2.modulus（）;
}
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）
{doubled=c2.modulus（）;if（d!
=0）
{Complextemp;temp.real=（c1.real*c2.real+c1.imag*c2.imag）/d;temp.imag=（c1.imag*c2.real-c1.real*c2.imag）/d;returntemp;
}
else
{cout<<"Errorinoperation/ofComplex"<exit（-1）;
}
}
5、定义一个多项式类Polynomial，其实例为多项式：
a0+a1x+a2x2+...+anxn，该类具有如下
的接口：
classPolynomial
{......
public:
Polynomial（）;
Polynomial（doublecoefs[],intexps[],intsize）;
//系数数组、指数数组和项数
Polynomial（constPolynomial&）;
~Polynomial（）;
Polynomial&operator=（constPolynomial&）;
intdegree（）const;//最高幂指数
doubleevaluate（doublex）const;//计算多项式的值
booloperator==（constPolynomial&）const;
booloperator!
=（constPolynomial&）const;
Polynomialoperator+（constPolynomial&）const;
Polynomialoperator-（constPolynomial&）const;
Polynomialoperator*（constPolynomial&）const;
Polynomial&operator+=（constPolynomial&）;
Polynomial&operator-=（constPolynomial&）;
Polynomial&operator*=（constPolynomial&）;
};
解：
classPolynomial
{double*pcoefs;
int*pexps;
intnum_of_items;
intadd（constPolynomial&p,double*coefs,int*exps）const;
intsubtract（constPolynomial&p,double*coefs,int*exps）const;
public:
Polynomial（）;
Polynomial（doublecoefs[],intexps[],intsize）;
Polynomial（constPolynomial&p）;
~Polynomial（）;
Polynomial&operator=（constPolynomial&p）;
intdegree（）const;
doubleevaluate（doublex）const;
booloperator==（constPolynomial&p）const;
booloperator!
=（constPolynomial&p）const;
Polynomialoperator+（constPolynomial&p）const;
Polynomialoperator-（constPolynomial&p）const;
Polynomialoperator*（constPolynomial&p）const;
Polynomial&operator+=（constPolynomial&p）;
Polynomial&operator-=（constPolynomial&p）;
Polynomial&operator*=（constPolynomial&p）;
};
intPolynomial:
:
add（constPolynomial&p,double*coefs,int*exps）const
{intcount=0,i=0,j=0;
while（i{if（pcoefs[i]!
=-p.pcoefs[j]）
{coefs[count]=pcoefs[i]+p.pcoefs[j];exps[count]=pexps[i];
count++;
}
i++;j++;
}
elseif（pexps[i]{coefs[count]=pcoefs[i];
exps[count]=pexps[i];
count++;i++;
}
else
{coefs[count]=p.pcoefs[j];exps[count]=p.pexps[j];
count++;j++;
}
}
if（iwhile（i{coefs[count]=pcoefs[i];
exps[count]=pexps[i];
count++;i++;
}
else
while（j{coefs[count]=p.pcoefs[j];
exps[count]=p.pexps[j];
count++;j++;
}
returncount;
}
intPolynomial:
:
subtract（const
Polynomial
&p,double
*coefs,
int
*exps）
const
{intcount=0,i=0,j=0;
while（i{if（pexps[i]==p.pexps[j]）{if（pcoefs[i]!
=p.pcoefs[j]）
{coefs[count]=pcoefs[i]-p.pcoefs[j];exps[count]=pexps[i];
count++;
}
i++;j++;
}
elseif（pexps[i]{coefs[count]=pcoefs[i];exps[count]=pexps[i];
count++;i++;
}
else
{coefs[count]=-p.pcoefs[j];exps[count]=p.pexps[j];count++;j++;
}
}
if（iwhile（i{coefs[count]=pcoefs[i];
exps[count]=pexps[i];count++;i++;
}
else
while（j{coefs[count]=-p.pcoefs[j];
exps[count]=p.pexps[j];
count++;j++;
}
returncount;
}
Polynomial:
:
Polynomial（）
{pcoefs=NULL;
pexps=NULL;
num_of_items=0;
}
Polynomial:
:
Polynomial（doublecoefs[],intexps[],intsize）
{num_of_items=size;
pcoefs=newdouble[num_of_items];
pexps=newint[num_of_items];
inti;
for（i=0;i{pcoefs[i]=coefs[i];pexps[i]=exps[i];
}
//按指数排序（冒泡排序）
for（i=num_of_items;i>1;i--）
{boolexchange=false;for（intj=1;j
{if（pexps[j]{//交换pexps[j]和pexps[j-1]
inttemp1=pexps[j];
pexps[j]=pexps[j-1];
pexps[j-1]=temp1;
//交换pcoefs[j]和pcoefs[j-1]
doubletemp2=pcoefs[j];
pcoefs[j]=pcoefs[j-1];
pcoefs[j-1]=temp2;
exchange=true;
}
}
if（!
exchange）break;
}
}
Polynomial:
:
Polynomial（constPolynomial&p）
{num_of_items=p.num_of_items;
pcoefs=newdouble[num_of_items];pexps=newint[num_of_items];
for（inti=0;i{pcoefs[i]=p.pcoefs[i];pexps[i]=p.pexps[i];
}
}
Polynomial:
:
~Polynomial（）
{delete[]pcoefs;delete[]pexps;
pcoefs=NULL;
pexps=NULL;
num_of_items=0;
}
Polynomial&Polynomial:
:
operator=（constPolynomial&p）
{delete[]pcoefs;
delete[]pexps;
num_of_items=p.num_of_items;
pcoefs=newdouble[num_of_items];
pexps=newint[num_of_items];for（inti=0;ipexps[i]=p.pexps[i];
}
return*this;
}
intPolynomial:
:
degree（）const
{if（num_of_items==0）return0;
else
returnpexps[num_of_items-1];
}
doublePolynomial:
:
evaluate（doublex）const
{doublesum=0;
for（inti=0;i{doubletemp=pcoefs[i];
for（intj=0;jtemp*=x;
sum+=temp;
}
returnsum;
}
boolPolynomial:
:
operator==（constPolynomial&p）const
{if（num_of_items!
=p.num_of_items）returnfalse;for（inti=0;iif（pcoefs[i]!
=p.pcoefs[i]||pexps[i]!
=p.pexps[i]）returnfalse;
returntr
升级会员 