静态成员、继承

搭建一个货币的场景,创建一个名为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(){}
    //有参构造函数
    RMB(int yuan,int jiao,int fen):yuan(yuan),jiao(jiao),fen(fen){
        count++;
    }
    //析构函数
    ~RMB()
    {
        count--;
    }

    //重载算数运算符+
    const RMB operator+(const RMB &R) const
    {
        RMB temp;
        temp.yuan = yuan + R.yuan;
        temp.jiao = jiao + R.jiao;
        temp.fen = fen + R.fen;
        int jiao_num = temp.jiao%10;
        int fen_num = temp.fen%10;
        if(temp.jiao >=10)
        {
            temp.jiao = jiao_num;
            temp.yuan +=1;
        }
        if(temp.fen >=10)
        {
            temp.fen = fen_num;
            temp.jiao +=1;
            if(temp.jiao >=10)
            {
                int nub = temp.jiao%10;
                temp.yuan+=1;
                temp.jiao = nub;
            }
        }
        return temp;
    }
    //重载算术运算符-
    const RMB operator-(const RMB &R) const
    {
        RMB temp;
            temp.yuan = yuan - R.yuan;
            temp.jiao = jiao - R.jiao;
            temp.fen = fen - R.fen;
            int jtmp = abs(temp.jiao);
            int jiao_num = jtmp%10;
            int ftmp = abs(temp.fen);
            int fen_num = ftmp%10;
            if(temp.jiao<0)
            {
                if(jtmp>=10)
                {
                    temp.jiao = abs(jiao_num);
                    if(temp.yuan>0)
                    {
                        temp.yuan+=1;
                    }
                    if(temp.yuan<0)
                    {
                        temp.yuan-=1;
                    }
                }
            }
            if(temp.fen<0)
            {
                temp.fen = abs(temp.fen);
                if(ftmp>=10)
                {
                    temp.fen = abs(fen_num);
                    temp.jiao +=1;
                    if(abs(temp.jiao) >= 10)
                    {
                        temp.jiao = abs(temp.jiao%10);
                        if(temp.yuan > 0)
                        {
                            temp.yuan += 1;
                        }
                        if(temp.yuan < 0)
                        {
                            temp.yuan -= 1;
                        }
                    }
                }
            }
        return temp;
    }
    //重载关系运算符>
    bool operator>(const RMB &R) const
    {
        if(yuan > R.yuan && jiao > R.jiao)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    //重载前自减运算符
    RMB operator--()
    {
        RMB temp;
        temp.yuan = --yuan;
        temp.jiao = --jiao;
        temp.fen = --fen;
        return temp;
    }
    //重载后自减运算符
    RMB operator--(int)
    {
        RMB temp;
        temp.yuan = yuan--;
        temp.jiao = jiao--;
        temp.fen = fen--;
        return temp;
    }

    void show(){
        cout << yuan << "." << jiao << fen << "元" << endl;
    }
};
int RMB::count = 0;


int main()
{
    RMB r1(10,4,9);
    r1.show();
    RMB r2(10,4,1);
    if(r2>r1)
    {
        cout << "r2>r1" << endl;
    }
    else
    {
        cout << "r2<r1" << endl;
    }
    RMB r3;
    r3 = r1+r2;
    r3.show();
    RMB r4;
    r4 = r2--;
    r4.show();
    r2.show();
    RMB r5(9,5,6);
    RMB r6;
    r6 = r5-r1;
    r6.show();
    return 0;
}