搭建一个货币的场景，创建一个名为 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;
//搭建一个货币的场景，创建一个名为 RMB 的类，该类具有整型私有成员变量 yuan（元）、jiao（角）和 fen（分），并且具有以下功能：
class RMB
{
private://私有
    double yuan; //元
    double jiao; //角
    double fen;  //分
    static int count; // 数 静态数据成员
    //角分的进位函数
    void carry()
    {
        if(fen >= 10)
        {
            fen -= 10;
            jiao++;
        }
        if(jiao >= 10)
        {
            jiao -= 10;
            yuan++;
        }
    }
    //角分的借位处理
    void borrow()
    {
        if(fen < 0)
        {
            jiao--;//从角借位
            fen += 10;//借来的一角转十分
        }
        if(jiao < 0)
        {
            yuan--;//从元借位
            jiao += 10;//借来的一元转十角
        }
    }

public://公共
    RMB(){} //无参构造
    RMB(double y,double j,double f):yuan(y),jiao(j),fen(f)//有参构造
    {
        carry();
        ++count;
    }

    void show() //显示RMB对象的值
    {
        cout << yuan << "元" << jiao << "角" << fen << "分" << endl;
    }
    ~RMB() //析构函数
    {
        --count;
    }
    //(1)重载算术运算符 + 和 -，使得可以对两个 RMB 对象进行加法和减法运算，并返回一个新的 RMB 对象作为结果。
    //成员函数实现 + 号运算符重载
    const RMB operator+(const RMB &R)const
    {
        RMB temp;//定义一个新的RMB对象
        temp.yuan = yuan + R.yuan;
        temp.jiao = jiao + R.jiao;
        temp.fen = fen + R.fen;
        temp.carry();//调用进位函数
        return temp;//返回temp对象
    }
    //成员函数实现 - 号运算符重载
    const RMB operator-(const RMB &R)const
    {
        RMB temp1;//定义一个新的RMB对象
        temp1.yuan = yuan - R.yuan;
        temp1.jiao = jiao - R.jiao;
        temp1.fen = fen - R.fen;
        temp1.borrow();// 调用借位函数
        return temp1;//返回temp1对象
    }
    //(2)重载关系运算符 >，判断一个 RMB 对象是否大于另一个 RMB 对象，并返回 true 或 false。
    //成员函数实现 > 号运算符重载
    bool operator>(const RMB &R)const
    {
        if(yuan > R.yuan)
        {
            return true;
        }
        else if(yuan == R.yuan &&  jiao > R.jiao)
        {
            return true;
        }
        else if(yuan == R.yuan && jiao == R.jiao &&  fen > R.fen)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    //(3)重载前置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1
    //成员函数实现 前置-- 号运算符重载
    RMB& operator--()
    {
        --yuan;
        --jiao;
        --fen;
        return  *this;
    }
    //(4)重载后置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1
    //成员函数实现 后置-- 号运算符重载
    const RMB operator--(int)
    {
        RMB temp2;
        temp2.yuan = yuan--;
        temp2.jiao = jiao--;
        temp2.fen = fen--;
        return temp2;
    }
    //(5)另外， RMB 类还包含一个静态整型成员变量 count，用于记录当前已创建的 RMB 对象的数量。
       //每当创建一个新的 RMB 对象时，count 应该自增 1；每当销毁一个 RMB 对象时，count 应该自减 1。

    //获取RMB 对象的数量
    static int getcount()
    {
        return count;
    }
};

int RMB::count = 0;//定义并初始化静态成员变量 count
int main()
{
    //在main 函数中测试上述RMB 类的功能
    RMB money1(10,7,6);
    RMB money2(6,9,5);

    money1.show();
    money2.show();
    cout << "---------------------------------" << endl;
    RMB sum1 = money1 + money2;
    sum1.show();
    cout << "---------------------------------" << endl;
    RMB sum2 = money1 - money2;
    sum2.show();
    cout << "---------------------------------" << endl;
    if(money1 > money2)
    {
        cout << "money1 > money2" << endl;
    }
    else
    {
        cout << "money1 < money2" << endl;
    }
    cout << "---------------------------------" << endl;
    --money1;
    money1.show();
    --money2;
    money2.show();
    cout << "---------------------------------" << endl;
    money1--;
    money1.show();
    money2--;
    money2.show();
    cout << "---------------------------------" << endl;
    cout << "创建的RMB对象的数量：" << RMB::getcount() << endl;
    return 0;
}

运算结果