c 运算符的重载习题答案

1.概念填空题
1.1运算符重载是对已有的运算符赋予多重含义，使同一个运算符在作用于不同类型对象时导致不同的行为。

运算符重载的实质是函数重载，是类的多态性特征。

1.2可以定义一种特殊的类型转换函数，将类的对象转换成基本数据类型的数据。

但是这种类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。

类类型转换函数既没有参数，也不显式给出返回类型。

类类型函数中必须有return 表达式的语句返回函数值。

一个类可以定义多个类类型转换函数。

1.3运算符重载时其函数名由operator运算符构成。

成员函数重载双目运算符时,左操作数是对象,右操作数是函数参数。

2.简答题
2.2简述运算符重载的规则。

2.2简述重载单目运算符++、--，前置和后置时的差别。

2.3 C++中重运算符是否都可以重载?是否都可以重载成类的成员函数?是否都可以重载成类的友元函数?
2.4 构造函数作为类型转换函数的条件是什么。

3．选择题
3.1在下列运算符中,不能重载的是(B)
A.！
B. sizeof
C. new
D. delete
3.2 不能用友员函数重载的是(A)。

A.=
B.==
C.<=
D.++
3.3下列函数中,不能重载运算符的函数是(B)。

A.成员函数
B.构造函数
C.普通函数
D.友员函数
3.4如果表达式++i*k时中的”++”和”*”都是重载的友元运算符，则采用运算符函数调用格式，该表达式还可表示为（B）。

A．operator*(i.operator++(),k) B．operator*(operator++(i),k)
C．i.operator++().operator*(k) D．k.operator*(operator++(i))
3.5已知在一个类体中包含如下函数原型：VOLUME operator-(VOLUME)const；下列关于这个函数的叙述中，错误的是（B ）。

A．这是运算符-的重载运算符函数
B．这个函数所重载的运算符是一个一元运算符
C．这是一个成员函数
D．这个函数不改变数据成员的值
3.6在表达式x＋y*z中，+是作为成员函数重载的运算符，*是作为非成员函数重载的运算符。

下列叙述中正确的是（C ）。

A．operator+有两个参数，operator*有两个参数
B．operator+有两个参数，operator*有一个参数
C．operator+有一个参数，operator*有两个参数
D．operator+有一个参数，operator*有一个参数
4.写出下列程序运行结果
4.1#include <iostream>
#using namesoace std;
class T
{public:
T( ){a=0; b=0; c=0;}
T( int i,int j,int k)
{a=i; b =j;c=k;}
void get( int &i,int &j,int &k)
{i=a; j=b; k=c;}
T operator *(T obj);
private:
int a,b,c;
};
T T::operator *(T obj)
{T tempobj;
tempobj.a=a * obj.a;
tempobj.b=b * obj.b;
tempobj.c=c * obj.c;
return tempobj;
}
int main()
{T obj1( 1,2,3),obj2( 5,5,5),obj3;
int a,b,c;
obj3=obj1 * obj2;
obj3.get( a, b, c);
cout<<”(obj1 * obj2):\t”
<<”a=”<<a<<’\t’<<“b=”<<b<< '\t'<<”c=”<<c<<’\t’<<endl;
(obj2 * obj3 ).get( a, b, c);
cout<<“(obj2＊obj3):\t”
<<“a=”<<a<<'\t'<<”b=”<<b<<’\t’<<“c=”<<c<<'\t’<<endl;
}
(obj1*obj2): a=5 b=10 c=15
(obj2*obj3): a=25 b=50 c=75
5．编程题
5．1将第4章练习5.7的分数类Fraction的算术运算改写成运算符重载函数,使分数类能实现通常的分数+、-、*、/等运算。

#include <iostream>
using namespace std;
class Fraction{
int numerator,denominator;
int common_divisor(); //计算最大公约数
void contracted(); //分数化简
public:
Fraction(int=0,int=1);
Fraction(Fraction&);
Fraction operator+(Fraction);
Fraction operator-(Fraction);
Fraction operator*(Fraction);
Fraction operator/(Fraction);
void Set(int=0,int=1);
void disp(){cout<<"fraction= "<<numerator<<"/"<<denominator<<endl;}
};
Fraction::Fraction(int num,int deno){
Set(num, deno);
}
Fraction::Fraction(Fraction& f){
numerator=f.numerator;
denominator=f.denominator;
}
Fraction Fraction::operator+(Fraction f){
Fraction
Temp(numerator*f.denominator+f.numerator*denominator,denominator*f.denominator) ;
Temp.contracted();
return Temp;
}
Fraction Fraction::operator-(Fraction f){
Fraction
Temp(numerator*f.denominator-f.numerator*denominator,denominator*f.denominator) ;
Temp.contracted();
return Temp;
}
Fraction Fraction::operator*(Fraction f){
Fraction Temp(numerator*f.numerator,denominator*f.denominator);
Temp.contracted();
return Temp;
}
Fraction Fraction::operator/(Fraction f){
Fraction Temp(f.denominator,f.numerator );
Temp=operator*(Temp);
Temp.contracted();
return Temp;
}
int Fraction::common_divisor(){
int residue;
int dividend=numerator,divisor=denominator;
while(residue=dividend%divisor){
dividend=divisor;
divisor=residue;
}
return divisor;
}
void Fraction::contracted()
{
int residue=common_divisor();
numerator/=residue;
denominator/=residue;
if(denominator<0){numerator*=-1;denominator*=-1;}
}
void Fraction::Set(int num,int deno){
if(deno!=0){
numerator=num;denominator=deno;
contracted();
}
}
void main(){
Fraction f1(1,3),f2(2,5),f3,f4,f5(2,8),f6,f7(8,3),f8(8,3),f9(1,4);
f4=f1+f2;
f4.disp();
f6=f2/f5/f7;
f6.disp();
f5.disp();
f6=f1-f2;
f6.disp();
}
5．2设向量X=(x1,x2,…,x n)和Y=(y1,y2…,y n),它们之间的加、减分别定义为： X+Y=(x1+y1,x2+y2,…,x n+y n)
X-Y=(x1-y1,x2-y2,…,x n-y n)
编程序定义向量类Vector ,重载运算符”+”、”-“、”=”,实现向量之间的加、减和赋值运算;用重载运算符”>>”、”<<”做向量的输入/输出操作。

注意检测运算的合法性。

#include <iostream.h>
//using namespace std;
class Vector{
int vec[10];
public:
Vector(int v[10]);
Vector();
Vector(Vector&);
Vector operator+(Vector&);
Vector operator-(Vector&);
friend ostream& operator<<(ostream& out, Vector&); };
Vector::Vector(int v[10]){
int i;
for(i=0;i<10;i++)vec[i]=v[i];
}
Vector::Vector(){
int i;
for(i=0;i<10;i++)vec[i]=0;
}
Vector::Vector(Vector& v){
int i;
for(i=0;i<10;i++)vec[i]=v.vec[i];
}
Vector Vector::operator+(Vector& v){
Vector z;
int i;
for(i=0;i<10;i++)
z.vec[i]=vec[i]+v.vec[i];
return z;
}
Vector Vector::operator-(Vector& v){
Vector z;
int i;
for(i=0;i<10;i++)
z.vec[i]=vec[i]-v.vec[i];
return z;
}
ostream& operator<<(ostream& out, Vector& v){ for(int i=0;i<10;i++)
out<<v.vec[i]<<",";
return out;
}
void main(){
int a[10]={-4,1,0,10,5,-9,8,13,6,2,};
int b[10]={-11,8,10,17,-6,9,6,7,12,5};
Vector v1(a),v2(b),v3,v4;
v3=v1+v2;
v4=v2-v1;
cout<<v3<<endl;
cout<<v4<<endl;
}
5.3定义一个类nauticalmile_kilometer,它包含两个数据成员kilometer(km)和meter(m)。

还包含一个构造函数对数据成员的初始化;成员函数print用于输出数据成员kilometer和meter的值;类型转换函数double()实现把千米和米转换为海里(1mile=1852m)。

编写main 函数，测试类nauticalmile_kilometer。

#include <iostream>
using namespace std;
class nauticalmile_kilometer{
int kilometer,meter;
public:
nauticalmile_kilometer(int =0,int =0);
operator double();
void print(){
cout<<kilometer<<","<<meter;
}
};
nauticalmile_kilometer::operator double(){
return kilometer*meter/1852.0;
}
nauticalmile_kilometer::nauticalmile_kilometer(int k,int m){
kilometer=k;
meter=m;
}
void main(){
nauticalmile_kilometer km(3,657);
double d=km;
cout<<d<<endl;。