1，

搭建一个货币的场景，创建一个名为 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
{
    //全局函数加上友元要在类里面声明；
    friend const RMB operator+(const RMB &L,const RMB &H);
    friend const RMB operator-(const RMB &L,const RMB &H);
    friend bool operator>(const RMB &L,const RMB &H);
    friend RMB &operator--(RMB &O);
    friend RMB operator--(RMB &O,int);
private:
    int first;
    int angle;
    int minute;
    static int count;
public:
    //无参
    RMB()
    {
        //cout << "无参构造" << endl;
        count++;
    }
    //有参
    RMB(int first,int angle,int minute):first(first),angle(angle),minute(minute)
    {
        //cout << "有参构造" << endl;
        count++;
    }
    //拷贝构造函数
    RMB(const RMB &other):first(other.first),angle(other.angle),minute(other.minute)
    {
        cout << "RMB=浅拷贝构造函数" << endl;
        count++;
    }
    //析构函数
    ~RMB()
    {
        //cout << "析构函数" << endl;
        count--;
    }
    //设置一个静态成员函数，获取
    static int acquirt()
    {
        return count;
    }


    //输出数据成员
    void show()
    {
        cout << "first元= " << first << endl;
        cout << "angle角= " << angle << endl;
        cout << "minute分= " << minute << endl;
    }


};
//全局函数实现+号运算重载
const RMB operator+(const RMB &L,const RMB &H)
{
    RMB temp;
    temp.first=L.first+H.first;
    temp.angle=L.angle+H.angle;
    temp.minute=L.minute+H.minute;
    return temp;
}
//全局函数实现-号运算重载
const RMB operator-(const RMB &L,const RMB &H)
{
    RMB temp;
    temp.first=L.first-H.first;
    temp.angle=L.angle-H.angle;
    temp.minute=L.minute-H.minute;
    return temp;
}
//全局函数实现关系运算重载
bool operator>(const RMB &L,const RMB &H)
{
    if(L.first > H.first && L.angle > H.angle && L.minute > H.minute)
    {
        return true;
    }
    else {
        return false;
    }
}
//全局前置自减运算
RMB &operator--(RMB &O)
{
    --O.first;
    --O.angle;
    --O.minute;
    return O;
}
//全局后置自减运算
RMB operator--(RMB &O,int)
{
    RMB temp;
    temp.first=O.first--;
    temp.angle=O.angle--;
    temp.minute=O.minute--;
    return temp;
}

//静态数据成员初始化
int RMB::count=0;

int main()
{
    //测试数据
    RMB s1(300,30,3);
    RMB s2(200,20,2);
    cout << "<=========================>" << endl;
    //全局加法运算
    RMB s3=s1+s2;
    s3.show();
    cout << "<=========================>" << endl;
    //全局减法运算
    RMB s4=s3-s2;
    s4.show();
    cout << "<=========================>" << endl;
    //全局关系运算重载
    if(s1>s2)
    {
        cout << "s1>s2" << endl;
    }
    cout << "<=========================>" << endl;
    //全局前置--运算重载
    RMB s5(8,8,8);
    s4=--s5;
    s5.show();
    s4.show();
    cout << "<=========================>" << endl;
    //全局后置--运算重载
    s4=s5--;
    s5.show();
    s4.show();
    cout << "静态变量功能测试" << endl;
    cout << "现存的RMB的对象" << RMB::acquirt() << endl;
    RMB* s6=new RMB(600,60,6);
    cout << "现存的RMB的对象" << RMB::acquirt() << endl;
    delete s6;
    cout << "现存的RMB的对象" << RMB::acquirt() << endl;


    return 0;
}

思维导图