运算符重载的例子

/// @file ClassroomExamples.cpp
/// @brief 2015-1223课堂笔记的验证代码

#include <iostream>
#include <limits>
#include "RMB.h"

using namespace std;

void clear_cin();
void fnTest_Operator_overloading();

int main(int argc, char** argv, char** envp)
{
    fnTest_Operator_overloading();
    cout << "END, press any key to quit" << endl;
    clear_cin();
    getchar();
    
    return 0;
}

void fnTest_Operator_overloading()
{
    CRMB rmb1(10);
    CRMB rmb2(11);
    CRMB rmb3(2.62);
    CRMB* pRmb = NULL;

    pRmb = new CRMB();
    delete pRmb;

    cout << rmb3 << endl;

    rmb3 = (double)1 + rmb1;
    rmb3 = (double)12 - rmb1;

    rmb3 = rmb1 + (double)1;
    rmb3 = rmb1 - 2.1;
    rmb3 = rmb1 + rmb2;
    rmb3 = rmb1 - rmb2;
    rmb2 = rmb1;

    cout << (rmb1 == rmb2) << endl;
    cout << (rmb1 > rmb2) << endl;
    cout << (rmb1 >= rmb2) << endl;
    cout << (rmb1 < rmb2) << endl;
    cout << (rmb1 <= rmb2) << endl;

    rmb1 += 10;
    rmb1 -= 2;
    cout << (++rmb1).getRmb() << endl;
    cout << (--rmb1).getRmb() << endl;
    cout << (rmb1--).getRmb() << endl;
    cout << (rmb1++).getRmb() << endl;

    cout << "rmb1.getRmb() = " << rmb1.getRmb() << endl;
}

void clear_cin()
{
    cin.clear();
    cin.sync();
}

// RMB.h: interface for the CRMB class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_RMB_H__E46A1710_9261_4FD9_999D_9865D891E42C__INCLUDED_)
#define AFX_RMB_H__E46A1710_9261_4FD9_999D_9865D891E42C__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <string>
#include <iostream>
#include <iomanip>
#include <stddef.h>

using namespace std;

class CRMB  
{
    /// 友元函数(不能再类内实现的功能)
    friend CRMB operator + (double dblAddTo, const CRMB& right);

    friend ostream& operator<< (ostream& cout, CRMB& right)
    {
        cout << "right.getAddr() = 0X" 
            << hex 
            << setfill('0') << setw(8) 
            << setiosflags(ios::uppercase)
            << right.getAddr() << endl;

        cout << "right.getRmb() = " << right.getRmb() << endl;
        return cout;
    }

    /// 构造,析构,拷贝构造函数
public:
    explicit CRMB(double dblRmb = 0); ///< 不允许隐式转换
    CRMB(const CRMB& src);
    virtual ~CRMB();
    
    /// 转换运算符重载
    /// 如果不定义"转换运算符重载", 
    /// 就走构造函数了 explicit CRMB(double dblRmb = 0)
    /** 应用场合
    rmb3 = (double)1 + rmb1;
    rmb3 = (double)12 - rmb1;
    rmb3 = rmb1 + (double)1;
    */
    operator double ()
    {
        return m_dblRmb;
    }

    /// 运算符重载
public:
    inline CRMB& operator = (const CRMB& src)
    {
        cpy(&src);
        return *this;
    }

    //友元全局函数重载, 类内实现
    friend CRMB operator + (double dblAddTo, const CRMB& right)
    {
        return CRMB(dblAddTo + right.getRmb());
    }

    /// 只拦截 new CRMB 的操作
    static void* operator new(size_t nSize)
    {
        void* pNewPt = NULL;

        pNewPt = ::operator new(nSize);

        if (NULL != pNewPt)
        {
            cout << "new CRMB = 0X" 
                << hex 
                << setfill('0') << setw(8) 
                << setiosflags(ios::uppercase)
                << pNewPt 
                << " nSize = "
                << nSize
                << endl;
        }
        
        return pNewPt;
    }
    
    /// 只拦截 delete CRMB 的操作
    static void operator delete(void* pRmb)
    {
        if (NULL != pRmb)
        {
            cout << "delete CRMB = 0X" 
                << hex 
                << setfill('0') << setw(8) 
                << setiosflags(ios::uppercase)
                << pRmb 
                << endl;

            ::operator delete(pRmb);
        }
    }

    CRMB operator + (double dblAddTo)
    {
        return CRMB(getRmb() + dblAddTo);
    }

    CRMB operator + (const CRMB src)
    {
        return CRMB(getRmb() + src.getRmb());
    }

    CRMB operator - (double dblSubTo)
    {
        return CRMB(getRmb() - dblSubTo);
    }
    
    CRMB operator - (const CRMB src)
    {
        return CRMB(getRmb() - src.getRmb());
    }

    inline void operator += (double dbl) {m_dblRmb += dbl;}
    inline void operator -= (double dbl) {m_dblRmb -= dbl;}
    inline CRMB& operator ++() ///< 前++
    {
        ++m_dblRmb;
        return *this;
    }

    inline CRMB operator ++(int) ///< 后++
    {
        return m_dblRmb++;
    }

    inline CRMB& operator --() ///< 前--
    {
        --m_dblRmb;
        return *this;
    }

    inline CRMB operator --(int) ///< 后--
    {
        return m_dblRmb--;
    }

    inline bool operator == (const CRMB& right) const
    {
        return isEqual(getRmb(), right.getRmb());
    }

    inline bool operator > (const CRMB& right) const
    {
        return (getRmb() > right.getRmb());
    }

    inline bool operator >= (const CRMB& right) const
    {
        return (getRmb() >= right.getRmb());
    }

    inline bool operator < (const CRMB& right) const
    {
        return (getRmb() < right.getRmb());
    }
    
    inline bool operator <= (const CRMB& right) const
    {
        return (getRmb() <= right.getRmb());
    }

    /// 成员函数
public:
    inline double getRmb() const {return m_dblRmb;}
    inline int getAddr() {return (int)this;}

private:
    void cpy(const CRMB* pSrc);
    bool isEqual(double dblLeft, double dblRight) const;
    
    /// 成员变量
private:
    double m_dblRmb; ///< 钱数
};

//友元全局函数重载, 类外实现
/// 实现在RMB.cpp
CRMB operator - (double dblAddTo, const CRMB& right);

#endif // !defined(AFX_RMB_H__E46A1710_9261_4FD9_999D_9865D891E42C__INCLUDED_)

// RMB.cpp: implementation of the CRMB class.
//
//////////////////////////////////////////////////////////////////////

#include "RMB.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CRMB::CRMB(double dblRmb /*= 0*/)
:m_dblRmb(dblRmb)
{
    
}

CRMB::~CRMB()
{
    
}

CRMB::CRMB(const CRMB& src)
{
    cpy(&src);
}

void CRMB::cpy(const CRMB* pSrc)
{
    if (this == pSrc)
    {
        return;
    }
    
    m_dblRmb = pSrc->m_dblRmb;
}

bool CRMB::isEqual(double dblLeft, double dblRight) const
{
    double dblDifference = dblLeft - dblRight;
    const double dblPrecision = 0.00000001;
    return ((dblDifference >= -dblPrecision) 
        && (dblDifference <= dblPrecision));
}

CRMB operator - (double dblAddTo, const CRMB& right)
{
    return CRMB(dblAddTo - right.getRmb());
}