第六章：习题

最新推荐文章于 2022-04-15 16:35:29 发布

WQB0708

最新推荐文章于 2022-04-15 16:35:29 发布

阅读量316

点赞数

本文链接：https://blog.csdn.net/WQB0708/article/details/80669740

版权

一、填空题

（1）运算符的重载实际上是函数的重载。

（2）运算符函数必须被重载为非静态成员函数，或被重载为友元函数。

（3）成员函数重载运算符需要的参数的个数总比它的操作数少一个。

（4）重载赋值运算符时，通常返回调用该运算符的对象的引用，这样赋值就能进行连续赋值操作。

（5）重载“[ ]”函数必须且只能带整型个形参，且规定其参数的类型。

（6）重载调用运算符函数可以带有多个参数。

二、选择题

（1）下列运算符中，不能被重载的是（B）。

A. [ ]

B. ●

C. ( )

（2）下列描述重载运算符的规则中，不正确的是（C）。

A. 重载运算符必须符合语言语法

B. 不能创建新的运算符

C. 不能改变运算符操作的类型

D. 不能改变运算符原有的优先级

（3）下列运算符中，不能有友元函数重载的是（A）

A. =

B.>

C. <

D. <>

（4）下列描述中，不正确的是（C）。

A. 赋值运算符有时也需要重载

B. 在重载增量或减量运算符时，若应用友元函数，则需要使用引用参数

C. 在任何情况下，重载运算符即可用友元函数，也可用成员函数

D. 若在某自定义类中重载了下标运算符“[ ]”,则可将该类的类对象当作一个“数组”

三、判断题

（1）下标运算符的重载提供了在C++中实现安全的数组下标的一种方法。（对）

（2）对下标运算符“[ ]”,即可重载为类成员函数，又可重载为友元函数。（错）

（3）重载后缀“++”运算符时多给出的一个int参数，在函数体中并不被使用。（对）

（4）重载运算符需要的参数个数与操作数一样多。（错）

四、简答题

（1）比较两种运算符重载形式。

答：在许多情况下，用友元函数还是成员函数重载运算符在功能上没有什么区别；有时将二元运算符重载为友元函数比重载为成员函数使用起来方便。当然，重载为友元函数也有一些限制。第一，为保持与C++中规定的赋值语义相一致，虽然赋值运算符是个二元操作符，但不能重载为友元函数。同样，也应将“+=”、“-=”等赋值运算符重载为成员函数。第二，友元函数不能重载“（）”、“[ ]”和“->”运算符。第三，在重载增量或减量运算符时，若使用友元函数，则需要应用引用参数。

（2）赋值运算符重载与拷贝构造函数有什么区别？

答：拷贝构造函数和赋值运算符重载函数都是用来拷贝一个类的对象给另一个同类型的对象。要注意拷贝构造函数与赋值运算符重载函数的使用区别。
①拷贝构造函数是用已存在对象的各成员的当前值来创建一个相同的新对象。在下述3种情况下，系统将自动调用所属类的拷贝构造函数：
●当说明新的类的对象的同时，要给它赋值另一个已存在对象的各成员当前值。
●当对象作为函数的赋值参数而对函数进行调用要进行实参和形参的结合时。
●当函数的返回值是类的对象，在函数调用结束后返回到主调函数处。
②赋值运算符重载函数要把一个已存在对象的各成员当前值赋值给另一个已存在的同类对象。

（3）重载前缀“++”运算符与重载后缀“++”运算符在形式上有什么不同？

答：重载后缀运算符带有形参int而重载前缀运算符没有。

以成员函数方式重载前缀“++”运算符的函数原型的一般格式如下：

<返回类型>：：operator++（）；

以类成员方式重载后缀“++”运算符的函数原型的一般格式如下：

<返回类型>：：operator++（int）；

以友元函数方式重载前缀“++”运算符的函数原型格式如下：

<返回类型>：：operator++（<类名>&）；

以友元方式重载后缀“++”运算符的函数原型格式如下：

<返回类型>：：operator++（<类名>&，int）；

五、程序设计题

（1）在C++中，分数不是预先定义的，需建立一个分数类，使之具有下述功能：能防止分母为“0”，当分数不是最简形式时进行约分以及避免分母为负数。用重载函数运算符完成加法、减法、乘法以及除法等四则运算。

[html] view plain copy print ?

#include<iostream>
#include<cstdlib>
using namespace std;
int gcd(int m,int n)//求最大公约数函数
{
if (m < n)
{
int tmp = m;
m = n;
n = tmp;
}
if (n == 0)
return m;
else
return gcd(n,m % n);
}
class fraction //构建分数类
{
int a,b;
public:
fraction(int x=0,int y=1) //构造函数
{
if(y==0) //判断分母是否为0
{
cout<<"分母为零"<<endl;
exit(0);
}
if(y<0) //分母小于0时将负号转移到分子上
{
a=(-1)*x;
b=(-1)*y;
}
a=x;
b=y;
}
fraction(const fraction&f)//拷贝构造
{
a=f.a;
b=f.b;
}
~fraction(){}//析构函数
void setfraction(int x,int y)//在类外重新设置分数值
{
if(y==0)
{
cout<<"分母为零"<<endl;
exit(0);
}
if(y<0)
{
a=(-1)*x;
b=(-1)*y;
}
a=x;
b=y;
}
void show()//输出最简结果
{
int flag=1,m;
if(a<0)
{
a=-a;
flag=-flag;
}
if(b<0)
{
b=-b;
flag=-flag;
}
m=gcd(a,b);
a=a/m;
b=b/m;
a=a*flag;
if(a==0||b==1)
cout<<a<<endl;
else
cout<<a<<"/"<<b<<endl;
}
friend fraction operator + (fraction & f1,fraction & f2 ) //以友元函数重载运算符
{
return fraction(f1.a * f2.b + f1.b * f2.a , f1.b * f2.b);
}
friend fraction operator - (fraction & f1,fraction & f2)
{
return fraction(f1.a*f2.b-f1.b*f2.a,f1.b*f2.b);
}
friend fraction operator * (fraction & f1,fraction & f2)
{
return fraction(f1.a*f2.a,f1.b*f2.b);
}
friend fraction operator / (fraction & f1,fraction & f2)
{
return fraction(f1.a*f2.b,f1.b*f2.a);
}
};
int main()
{
int a,b;
cout<<"请输入第一个分数的分子分母"<<endl;
cin>>a>>b;
int c,d;
cout<<"请输入第二个分数的分子分母"<<endl;
cin>>c>>d;
fraction a1,a2,a3,a4,a5,a6;
a1.setfraction(a,b);
a2.setfraction(c,d);
a3=a1+a2;
cout<<"加法结果"<<endl;
a3.show();
a4=a1-a2;
cout<<"减法结果"<<endl;
a4.show();
a5=a1*a2;
cout<<"乘法法结果"<<endl;
a5.show();
a6=a1/a2;
cout<<"除法法结果"<<endl;
a6.show();
return 0;
}

#include<iostream>    
    
#include<cstdlib>    
    
using namespace std;    
    
int gcd(int m,int n)//求最大公约数函数    
    
{    
    
    if (m < n)    
    
    {    
    
        int tmp = m;    
    
        m = n;    
    
        n = tmp;    
    
    }    
    
    if (n == 0)    
    
        return m;    
    
    else    
    
        return gcd(n,m % n);    
    
}    
    
    
    
class fraction   //构建分数类    
    
{    
    
    int a,b;    
    
public:    
    
    fraction(int x=0,int y=1)         //构造函数    
    
    {    
    
        if(y==0)                      //判断分母是否为0    
    
              {    
    
                     cout<<"分母为零"<<endl;    
    
                     exit(0);    
    
              }    
    
        if(y<0)                         //分母小于0时将负号转移到分子上    
    
        {    
    
            a=(-1)*x;    
    
            b=(-1)*y;    
    
        }    
    
        a=x;    
    
        b=y;    
    
    }    
    
    fraction(const fraction&f)//拷贝构造    
    
    {    
    
        a=f.a;    
    
        b=f.b;    
    
}    
    
~fraction(){}//析构函数    
    
    void setfraction(int x,int y)//在类外重新设置分数值    
    
    {    
    
        if(y==0)    
    
          {    
    
                     cout<<"分母为零"<<endl;    
    
                     exit(0);    
    
              }    
    
        if(y<0)    
    
        {    
    
            a=(-1)*x;    
    
            b=(-1)*y;    
    
        }    
    
        a=x;    
    
        b=y;    
    
    }    
    
    void show()//输出最简结果    
    
    
    
    {    
    
        int flag=1,m;    
    
        if(a<0)    
    
        {    
    
            a=-a;    
    
            flag=-flag;    
    
        }    
    
        if(b<0)    
    
        {    
    
            b=-b;    
    
            flag=-flag;    
    
        }    
    
              m=gcd(a,b);    
    
        a=a/m;    
    
        b=b/m;    
    
        a=a*flag;    
    
        if(a==0||b==1)    
    
            cout<<a<<endl;    
    
        else    
    
            cout<<a<<"/"<<b<<endl;    
    
}    
    
    friend   fraction operator  +  (fraction  &  f1,fraction & f2 ) //以友元函数重载运算符    
    
    {    
    
        return fraction(f1.a * f2.b + f1.b * f2.a , f1.b * f2.b);    
    
    }    
    
    friend  fraction operator  -  (fraction & f1,fraction & f2)    
    
    {    
    
        return fraction(f1.a*f2.b-f1.b*f2.a,f1.b*f2.b);    
    
    }    
    
    friend fraction operator  *  (fraction & f1,fraction & f2)    
    
    {    
    
        return fraction(f1.a*f2.a,f1.b*f2.b);    
    
    }    
    
    friend fraction operator  /  (fraction & f1,fraction & f2)    
    
    {    
    
        return fraction(f1.a*f2.b,f1.b*f2.a);    
    
    }    
    
};    
    
int main()    
    
{    
    
    int a,b;    
    
    cout<<"请输入第一个分数的分子分母"<<endl;    
    
    cin>>a>>b;    
    
    int c,d;    
    
    cout<<"请输入第二个分数的分子分母"<<endl;    
    
    cin>>c>>d;    
    
    fraction a1,a2,a3,a4,a5,a6;    
    
    a1.setfraction(a,b);    
    
    a2.setfraction(c,d);    
    
    a3=a1+a2;    
    
       cout<<"加法结果"<<endl;    
    
    a3.show();    
    
    a4=a1-a2;    
    
       cout<<"减法结果"<<endl;    
    
    a4.show();    
    
    a5=a1*a2;    
    
       cout<<"乘法法结果"<<endl;    
    
    a5.show();    
    
    a6=a1/a2;    
    
       cout<<"除法法结果"<<endl;    
    
a6.show();    
    
 return 0;    
    
}

运行结果如下：

（2）在第（1）题的基础上，用重载关系符“==”判断两个分数是否相等。

WQB0708

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第六章：习题

一、填空题（1）运算符的重载实际上是函数的重载。（2）运算符函数必须被重载为非静态成员函数，或被重载为友元函数。（3）成员函数重载运算符需要的参数的个数总比它的操作数少一个。（4）重载赋值运算符时，通常返回调用该运算符的对象的引用，这样赋值就能进行连续赋值操作。（5）重载“[ ]”函数必须且只能带整型个形参，且规定其参数的类型。（6...
复制链接

扫一扫