6.7作业

最新推荐文章于 2024-10-20 20:14:58 发布
最新推荐文章于 2024-10-20 20:14:58 发布
阅读量161 收藏
点赞数 3
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49364604/article/details/139584255
版权

搭建一个货币的场景，创建一个名为 RMB 的类，该类具有整型私有成员变量 yuan（元）、jiao（角）和 fen（分），并且具有以下功能：

(1)重载算术运算符 + 和 -，使得可以对两个 RMB 对象进行加法和减法运算，并返回一个新的 RMB 对象作为结果。

(2)重载关系运算符 >，判断一个 RMB 对象是否大于另一个 RMB 对象，并返回 true 或 false。

(3)重载前置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1

(4)重载后置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1

(5)另外， RMB 类还包含一个静态整型成员变量 count，用于记录当前已创建的 RMB 对象的数量。每当创建一个新的 RMB 对象时，count 应该自增 1；每当销毁一个 RMB 对象时，count 应该自减 1。

要求，需要在main 函数中测试上述RMB 类的功能。

#include <iostream>

using namespace std;
class Rmb
{
    //角分以十为单位
private:
    int yuan;
    int jiao;
    int fen;
    static int count;
public:
    Rmb(int yuan=0,int jiao=0,int fen=0):yuan(yuan),jiao(jiao),fen(fen)
    {
        int xjiao=0;
        if(this->fen>=10)
        {
            xjiao=(this->fen)/10;
            this->fen=(this->fen)%10;

        }
        this->jiao=(this->jiao)+xjiao;
        if(this->jiao>=10)
        {
            this->yuan=(this->yuan)+((this->jiao)/10);
            (this->jiao)=(this->jiao)%10;
        }

            count++;
            cout << "现在的Rmb对象有" << count << "个" << endl;

    }
    Rmb &operator=(const Rmb &other)
    {
        this->yuan=other.yuan;
        this->jiao=other.jiao;
        this->fen=other.fen;
//        int xjiao=0;
//        if(this->fen>=10)
//        {
//            xjiao=(this->fen)/10;
//            this->fen=(this->fen)%10;

//        }
//        this->jiao=(this->jiao)+xjiao;
//        if(this->jiao>=10)
//        {
//            this->yuan=(this->yuan)+((this->jiao)/10);
//            (this->jiao)=(this->jiao)%10;
//        }
        count++;
        return *this;
    }
    ~Rmb()
    {

            count--;
            cout << "死亡一个后现在的Rmb对象有" << count << "个" << endl;

    }

    const Rmb operator+(const Rmb &R)const
    {
        Rmb temp(0,0,0);
        temp.yuan=yuan+R.yuan;
        temp.jiao=jiao+R.jiao;
        temp.fen=fen+R.fen;
        int xjiao=0;
        if(temp.fen>=10)
        {
            xjiao=(temp.fen)/10;
            temp.fen=(temp.fen)%10;

        }
        temp.jiao=(temp.jiao)+xjiao;
        if(temp.jiao>=10)
        {
            temp.yuan=(temp.yuan)+((temp.jiao)/10);
            (temp.jiao)=(temp.jiao)%10;
        }
        return temp;
    }
    const Rmb operator-(const Rmb &R)const
    {
        Rmb temp;
        int yuan1=yuan;
        int jiao1=jiao;
        int fen1=fen;
        int yuan2=R.yuan;
        int jiao2=R.jiao;
        int fen2=R.fen;
        if(yuan1>yuan2)
        {
            if(fen1<fen2)
            {
                jiao1--;
                fen1=fen1+10;
                temp.fen=fen1-fen2;
                if(jiao1<jiao2)
                {
                    yuan1--;
                    jiao1=jiao1+10;
                    temp.jiao=jiao1-jiao2;
                    temp.yuan=yuan1-yuan2;
                    return temp;
                }
                else if(jiao1>=jiao2)
                {
                    temp.jiao=jiao1-jiao2;
                    temp.yuan=yuan1-yuan2;
                    return temp;
                }
            }
            else if(fen1>=fen2)
            {
                temp.fen=fen1-fen2;
                if(jiao1<jiao2)
                {
                    yuan1--;
                    jiao1=jiao1+10;
                    temp.jiao=jiao1-jiao2;
                    temp.yuan=yuan1-yuan2;
                    return temp;
                }
                else if(jiao1>=jiao2)
                {
                    temp.jiao=jiao1-jiao2;
                    temp.yuan=yuan1-yuan2;
                    return temp;
                }
            }
        }
        else if(yuan1==yuan2)
        {
            if(jiao1>jiao2)
            {
                if(fen1<fen2)
                {
                    jiao1--;
                    fen1=fen1+10;
                    temp.fen=fen1-fen2;
                    temp.jiao=jiao1-jiao2;
                    return temp;
                }
                else if(fen1>=fen2)
                {
                    temp.fen=fen1-fen2;
                    temp.jiao=jiao1-jiao2;
                    return temp;
                }
            }
            else if(jiao1==jiao2)
            {
                if(fen1>=fen2)
                {
                    temp.fen=fen1-fen2;
                }
                else if(fen1<fen2)
                {
                    cout << "减法不合法" << endl;
                    return temp;
                }
            }
            else if(jiao1<jiao2)
            {
                cout << "减法不合法" << endl;
                return temp;
            }
        }
        if(yuan1<yuan2)
        {
        cout << "减法不合法" << endl;
        return temp;
        }
        return temp;
    }
    bool operator>(const Rmb &R)const
    {
        if(yuan>R.yuan)
        {
            return 1;
        }
        else if(yuan==R.yuan)
        {
            if(jiao>R.jiao)
            {
                return 1;
            }
            else if(jiao==R.jiao)
            {
                if(fen>R.fen)
                {
                    return 1;
                }
            }
        }
        return 0;
    }
    Rmb &operator--()
    {
        fen--;
        if(fen<0)
        {
            fen=fen+10;
            jiao=jiao-2;
            if(jiao<0)
            {
                jiao=jiao+10;
                yuan=yuan-2;
                if(yuan<0)
                {
                    yuan=0;
                    jiao=0;
                    fen=0;
                }
            }
            else if(jiao>=0)
            {
                yuan=yuan-1;
                if(yuan<0)
                {
                    yuan=0;
                    jiao=0;
                    fen=0;
                }
            }

        }
        else if(fen>=0)
        {
            jiao--;
            if(jiao<0)
            {
                jiao=jiao+10;
                yuan=yuan-2;
                if(yuan<0)
                {
                    yuan=0;
                    jiao=0;
                    fen=0;
                    cout << "自减不合法" << endl;
                }
            }
            else if(jiao>=0)
            {
                yuan--;
                if(yuan<0)
                {
                    yuan=0;
                    jiao=0;
                    fen=0;
                    cout << "自减不合法" << endl;
                }
            }
        }
//        if(fen==0)
//        {
//            fen--;
//            fen=fen+10;
//            jiao--;
//        }
//        else
//        {
//            fen--;
//        }
//        if(jiao<=0)
//        {
//            jiao--;
//            jiao=jiao+10;
//            yuan--;
//        }
//        else
//        {
//            jiao--;
//        }
//        if(yuan<=0)
//        {
//            cout << "不合理" << endl;
//        }
//        else
//        {
//            yuan--;
//        }
        return *this;
    }

    const Rmb operator--(int)
    {
        Rmb temp=*this;
        fen--;
        if(fen<0)
        {
            fen=fen+10;
            jiao=jiao-2;
            if(jiao<0)
            {
                jiao=jiao+10;
                yuan=yuan-2;
                if(yuan<0)
                {
                    yuan=0;
                    jiao=0;
                    fen=0;
                }
            }
            else if(jiao>=0)
            {
                yuan=yuan-1;
                if(yuan<0)
                {
                    yuan=0;
                    jiao=0;
                    fen=0;
                }
            }

        }
        else if(fen>=0)
        {
            jiao--;
            if(jiao<0)
            {
                jiao=jiao+10;
                yuan=yuan-2;
                if(yuan<0)
                {
                    yuan=0;
                    jiao=0;
                    fen=0;
                    cout << "自减不合法" << endl;
                }
            }
            else if(jiao>=0)
            {
                yuan--;
                if(yuan<0)
                {
                    yuan=0;
                    jiao=0;
                    fen=0;
                    cout << "自减不合法" << endl;
                }
            }
        }
        return temp;
    }
    void show()
    {
        cout << yuan << " " << jiao << " " << fen << endl;
    }
};
int Rmb::count=0;
int main()
{
    Rmb r1(0,5,0);
    r1.show();
    Rmb r2(99,6,7);
    r2.show();
    if(r1>r2)
    {
        cout << "r1>r2" << endl;
    }
    Rmb r3=r1+r2;
    r3.show();
    r3=r2-r1;
    r3.show();
    --r1;
    r1.show();
    r1--;
    r1.show();
    return 0;
}

 

qq_49364604
关注
Linux5.6和6.7作业
weiaibudu的博客
05-12 265
5.6作业 1、创建mygroup组群，再创建myuser用户，并且此用户属于mygroup组群，接着以myuser身份登 录，创建ex和hv两个文件于/home/myuser目录，并使hv文件的同组用户是root。请依次写出相应执行的命令。 [root@bogon ~]# groupadd mygroup [root@bogon ~]# useradd myuser [root@bogon ~]# gpasswd -a myuser mygroup [root@bogon ~]# su - myuser
二年级数学下册六有余数的除法6.7综合练习作业课件新人教版202004072178
09-08
二年级数学下册六有余数的除法6.7综合练习作业课件新人教版202004072178
0610_C++5
slander_1120的博客
06-10 699
(5)另外， RMB 类还包含一个静态整型成员变量 count，用于记录当前已创建的 RMB 对象的数量。每当创建一个新的 RMB 对象时，count 应该自增 1；(1)重载算术运算符 + 和 -，使得可以对两个 RMB 对象进行加法和减法运算，并返回一个新的 RMB 对象作为结果。(2)重载关系运算符 >，判断一个 RMB 对象是否大于另一个 RMB 对象，并返回 true 或 false。(3)重载前置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1。
C++深度解析 类中的函数重载 -- 全局函数，普通成员函数，静态成员函数（28）
Tim的嵌入式之旅
12-29 1933
C++深度解析 类中的函数重载 -- 全局函数，普通成员函数，静态成员函数（28）       函数重载的回顾 函数重载的本质为相互独立的不同函数 C++中通过函数名和函数参数确定函数调用 无法直接通过函数名得到重载函数的入口地址 函数重载必然发生在同一个作用域中       类中的成员函数可以进行重载 构造函数的重载 普通成员函数的重载 静态成员函数的重载    ...
C++中函数重载
weixin_41584333的博客
02-15 740
C++中函数重载 C++代码在编译时会根据参数列表对函数进行重命名，例如void Swap(int a, int b)会被重命名为_Swap_int_int，void Swap(float x, float y)会被重命名为_Swap_float_float。当发生函数调用时，编译器会根据传入的实参去逐个匹配，以选择对应的函数，如果匹配失败，编译器就会报错 从这个角度讲，函数重载仅仅是语法层面的，本质上它们还是不同的函数，占用不同的内存，入口地址也不一样。 ...
【红对勾】（新课标）2016高考数学大一轮复习 6.7数学归纳法课时作业 理
08-07
标题和描述中的"课时作业 43 数学归纳法"表明这是一个关于数学归纳法的教学资料，用于高中数学的大一轮复习，适用于理科学生。标签“课件”提示这是一个教学辅助材料，可能包含习题和解答。 部分内容展示了数学归纳...
高考物理一轮复习6.7带电粒子在电场中的运动二作业无答案新人教版
08-19
【知识点详解】 1. **电场力与粒子运动轨迹**：题目中提到的带电粒子在不同电压下沿不同轨迹运动，这涉及到电场力与粒子初速度的关系。电场力F=qE，其中F是力，q是粒子的电荷，E是电场强度。粒子的轨迹取决于电场...
九年级数学下册第6章图形的相似6.7用相似三角形解决问题第1课时作业pdf无答案新版苏科版
09-09
九年级数学下册第6章图形的相似6.7用相似三角形解决问题第1课时作业pdf无答案新版苏科版
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 556
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
青少年编程能力等级测评CPA C++ 四级试卷（2）
轻描时光
10-20 437
（3）编程过程中对于程序给定的部分不允许修改，考生仅允许在/****code****/提示行区间内作答。（3）编程过程中对于程序给定的部分不允许修改，考生仅允许在/****code****/提示行区间内作答。CP4_2_13．将A类的成员函数fun()声明为B类的友元函数，则以下叙述中，正确的是（ ）。编程过程中对于程序给定的部分不允许修改，考生仅允许在/****code****/提示行区间内作答。CP4_2_2．若有如下类A的定义，则下列有关类成员访问权限的叙述中，正确的是（ ）。
2023-06 GESP C++三级试卷
ya888g
10-17 917
位同学，每位同学有从 0 到?到达的同学都会报出的编号，不会报出别人的编号，但有的同 学很顽皮，会多次报出。10 如果 a 为 int 类型的变量，且表达式((a | 3) == 3)的值为 true，则说 明 a 在从 0 到 3 之间（可能为 0、可能为 3）3 已知大写字符’A’的 ASCII 编码的十六进制表示为 0x41，则字符’F’的 ASCII 编码的十六进制表示为（ ）12 如果 a 为 int 类型的变量，下列哪个表达式可以正确求出满足“小于等于 a且是 4 的倍数”的整数中最大的（ ）
C++的魔法世界：类和对象的终章
sparrowfart的博客
10-16 1279
详细介绍，C++类和对象中初始化列表、隐式类型转换、匿名对象等相关知识
如何用c++模拟创建用户（只得创建一个用户）
2301_78863827的博客
10-14 779
模拟系列，希望大家能多提意见
青少年编程能力等级测评CPA C++（三级）-试卷2
轻描时光
10-20 688
CP3_2_9．已经按升序排列好的一组数“20,40,47,58,62,82,94”，使用二分查找算法在这组数中查找200，判断出200不在这组数中，需要比较的次数是（ ）。CP3_2_3．有数列1，1/1!CP3_2_5．使用选择排序算法（每趟最多交换一次）对一组数“19，28，12，7，66，31，24”进行升序排序，则第三趟结束后，这组数的顺序是（ ）。CP3_2_6．用直接插入排序算法对一组数“100，80，12，66，31，19，28”进行升序排序，则第四趟结束后，这组数的顺序是（ ）。
鹏哥C语言86-1---第14次作业：操作符的使用
most_wanted_的博客
10-20 488
/-----------------------------------------------------------------------------------1.位操作符。//-----------------------------------------------------------------------------------2.代码结果。//--------------------------------------------------------------方法1。
【C++】使用 yaml-cpp 库操作 YAML
coco的专栏
10-16 879
配置文件有利于我们灵活配置工程，解决大量重复劳动，也方便调试。YAML 是一种人类可读的数据序列化格式，它使用缩进和特定的符号来表示数据结构。在本文中，我们将详细介绍如何在 C++ 中使用yaml-cpp库来解析和生成 YAML 格式的数据。
Canmv k230 C++案例1.2——image classify项目 C++代码分析（待完成）
stoat04的博客
10-16 240
这部分为初学，所以手头最好有本工具书便于查阅。
C++ 类与对象（上）
最新发布
2201_75357870的博客
10-20 498
在C++中，类是一种，类似于C语言中的struct定义结构体。那么什么是对象呢？对象其实是类的类型实例化，就如我声明了一个栈，然后用栈的声明创建了一个栈，被创建的这个栈就是对象。类其实是对象的一种抽象描述，类似于一张施工的图纸，图纸上画了这个工程有什么东西，但是这张图纸上的内容在真实世界中并没有真实的东西，需要现实的人们根据图纸在现实世界创造出图纸里面的内容。对于类的定义，以class为关键字，后面加，{}中的内容为主体，与C语言结构体一样，{}后面要加分号（；
VMware vSphere 6.7 完全配置指南
13. **vSphere Data Protection配置**：部署VDP以实现虚拟机的备份和恢复，包括部署VDP模板、配置备份策略和创建备份作业。 14. **部署vRealize Operations Manager**：vRealize Operations Manager提供性能监控和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值