嵌入式学习

笔记

作业 

        搭建一个货币的场景，创建一个名为 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 类
class RMB
{
    //友元
    friend const RMB operator+(const RMB &L, const RMB &R);
    friend const RMB operator-(const RMB &L, const RMB &R);
    friend bool operator>(const RMB &L, const RMB &R);
    friend RMB &operator--(RMB &O);
    friend const RMB operator--(RMB &O,int);

private:
    double yuan;
    double jiao;
    double fen;
    static int count;

public:
    //无参构造函数
    RMB()
    {
        count++;
    }
    //有参构造函数
    RMB(double yuan, double jiao, double fen):yuan(yuan),jiao(jiao),fen(fen)
    {
        count++;
    }
    //析构函数
    ~RMB()
    {
        count--;
    }

    //显示当前对象的 yuan jiao fen
    void display()
    {
        cout <<"yuan=" << yuan << " " << "jiao=" << jiao << " " << "fen=" << fen << endl;
    }

    //静态成员函数，显示当前存在的 RMB对象 数量
    static int count_current()
    {
        cout << "RMB类对象现存数量：" << count << endl;
    }

    //成员函数实现 “+” 重载
//    const RMB operator+(const RMB &R)const
//    {
//        RMB temp;
//        temp.yuan = yuan + R.yuan;
//        temp.jiao = jiao + R.jiao;
//        temp.fen = fen + R.fen;
//        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;
//        return temp;
//    }

    //成员函数实现 “>” 重载
//    bool operator>(const RMB &R)const
//    {
//        return (yuan>R.yuan && jiao>R.jiao && fen>R.fen);
//    }

    //成员函数实现 前-- 重载
//    RMB &operator--()
//    {
//        --yuan;
//        --jiao;
//        --fen;
//        return *this;
//    }

    //成员函数实现 后-- 重载
//    const RMB operator--(int)
//    {
//        RMB temp;
//        temp.yuan = yuan--;
//        temp.jiao = jiao--;
//        temp.fen = fen--;
//        return temp;
//    }
};

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

//全局函数实现 “+” 重载
const RMB operator+(const RMB &L, const RMB &R)
{
    RMB temp;
    temp.yuan = L.yuan + R.yuan;
    temp.jiao = L.jiao + R.jiao;
    temp.fen = L.fen + R.fen;
    return temp;
}

//全局函数实现 “-” 重载
const RMB operator-(const RMB &L, const RMB &R)
{
    RMB temp;
    temp.yuan = L.yuan - R.yuan;
    temp.jiao = L.jiao - R.jiao;
    temp.fen = L.fen - R.fen;
    return temp;
}

//全局函数实现 “>” 重载
bool operator>(const RMB &L, const RMB &R)
{
    return (L.yuan>R.yuan && L.jiao>R.jiao && L.fen>R.fen);
}

//全局函数实现 前-- 重载
RMB &operator--(RMB &O)
{
    --O.yuan;
    --O.jiao;
    --O.fen;
    return O;
}

//全局函数实现 后-- 重载
const RMB operator--(RMB &O,int)
{
    RMB temp;
    temp.yuan = O.yuan--;
    temp.jiao = O.jiao--;
    temp.fen = O.fen--;
    return temp;
}


int main()
{
//    RMB r1(11, 5, 6);
//    RMB r2(10, 3, 4);
//    RMB::count_current();

//    RMB r3 = r1 + r2;//“+” 重载
//    r3.display();

//    cout << "===================" << endl;

//    RMB r4 = r1 - r2;//“-” 重载
//    r4.display();

//    cout << "===================" << endl;

//    //“>” 重载
//    if(r1 > r2)
//    {
//        cout << "r1 > r2" << endl;
//    }else {
//        cout << "r1 <= r2" << endl;
//    }

//    cout << "===================" << endl;

//    RMB r5 = --r1;//前-- 重载
//    r5.display();
//    r1.display();

//    cout << "===================" << endl;

//    RMB r6 = r2--;//后-- 重载
//    r6.display();
//    r2.display();



    RMB *r1 =new RMB(11, 5, 6);
    RMB *r2 = new RMB(10, 3, 4);
    RMB::count_current();

    RMB *r3 = new RMB(*r1 + *r2);//“+” 重载
    r3->display();

    cout << "===================" << endl;

    RMB *r4 = new RMB(*r1 - *r2);//“-” 重载
    r4->display();
    RMB::count_current();

    cout << "===================" << endl;

    cout << "回收r3" << endl;
    delete r3;
    RMB::count_current();
    cout << "回收r4" << endl;
    delete r4;
    RMB::count_current();

    cout << "===================" << endl;

    //“>” 重载
    if(*r1 > *r2)
    {
        cout << "r1 > r2" << endl;
    }else {
        cout << "r1 <= r2" << endl;
    }

    cout << "===================" << endl;

    //RMB *r5 = new RMB(--(*r1));//前-- 重载    执行这一句分配时有问题，少一个
    RMB *r5 = new RMB;
    *r5 = --(*r1);
    r5->display();
    r1->display();
    RMB::count_current();

    cout << "===================" << endl;

    RMB *r6 = new RMB((*r2)--);//后-- 重载
    r6->display();
    r2->display();
    RMB::count_current();

    cout << "===================" << endl;

    cout << "回收全部类对象" << endl;
    delete r1;
    delete r2;
    delete r5;
    delete r6;
    RMB::count_current();

    return 0;
}

执行结果：