思考: 对于一个要重载的运算符而言,什么样的运算符应该用类成员函数重载,什么情况应该用友元函数重载??

还是用一个例子来说明吧

#define unsigned int UINT32

class RMB
{
    public:
    RMB(UINT32 d, UINT32 c);
    friend RMB operator +(RMB&, RMB&);
    friend RMB& operator ++(RMB&);
    void display()
    {
        cout<<(yuan + jf / 100.0)<<endl;
    }
    
    protected:
    UINT32 yuan;    　　//元
    UINT32 jf;         //角分
};

RMB::RMB(UINT32 d, UINT32 c) : yuan(d), jf(c)
{
    while (jf >= 100)
    {
        yuan++;
        jf -= 100;
    }
}

RMB operator +(RMB& rmb1, RMB& rmb2)
{
    UINT32 jf = rmb1.jf + rmb2.jf;
    UINT32 yuan = rmb1.yuan + rmb2.yuan;
    return RMB(yuan, jf);
}

RMB& operator ++(RMB& rmb)
{
    s.jf++;
    if (jf >= 100)
    {
        s.yuan++;
        jf -= 100;
    }
    return rmb;
}

int main()
{
    RMB rmb1(1,60);
    RMB rmb2(2, 50);
    RMB rmb3(0,0);
    rmb3 = rmb1 + rmb2;  //4, 10
    ++rmb3;  //4, 11
    
    rmb3.display();
    
    return 0;
}
//问题思考:
  //1.前++定义 A& operator++(xxx);--->xxx不是int就可以   后++定义: A operator++(int)
  //2.第51行是可行的, 但是改为 rmb3 = 1.2 + rmb1  或者 rmb3 = 1.3 + 1.2  或者rmb3 = rmb1 + 1.2呢  是否还可以编译通过?

针对问题2,我们可以增加opertor的重载函数

    friend RMB operator +(double&, RMB&);
    friend RMB operator +(RMB&, double&);

但是这样很麻烦.

这里会利用类构造函数的隐式转换提供一个解决方案

 先用一个小例子来说明,隐式转换的用法
 1 #include<iostream>
using namespace std;

class A
{
    public:
        A(double ii):i(ii){}
        void print(A a)
        {
            cout<<a.i<<endl;
        }
        /*
         void print(A& a) //如果是A&的话,外部的隐式转换将不可用
        {
            cout<<a.i<<endl;
        }
         */
    private:
        double i;
};
int main()
{
    A a(3);
    A b(4);
    b.print(a);
    b.print(5);  //如果要使用隐式转换,print的形参必须不能使引用
    return 0;
}

好,接下来我们来看看我们的代码

#include<iostream>
using namespace std;

#define UINT32 unsigned int 

class RMB
{
    public:
        RMB(UINT32 d, UINT32 c);
        RMB(double value);   //提供隐式转换构造函数
        friend RMB operator +(RMB, RMB);  //从引用转为非引用

        friend RMB& operator ++(RMB&);
        void display()
        {
            cout<<(yuan + jf / 100.0)<<endl;
        }

    protected:
        UINT32 yuan;    //元
        UINT32 jf;        //角分
};

RMB::RMB(UINT32 d, UINT32 c) : yuan(d), jf(c)
{
    while (jf >= 100)
    {
        yuan++;
        jf -= 100;
    }
}

RMB::RMB(double value)
{
    yuan = static_cast<int>(value);
    jf = static_cast<int>( (value - yuan) * 100 + 0.5);  //+0.5是为了完成四舍五入. 
}

RMB operator +(RMB rmb1, RMB rmb2)    //从引用改为非引用
{
    UINT32 jf = rmb1.jf + rmb2.jf;
    UINT32 yuan = rmb1.yuan + rmb2.yuan;
    return RMB(yuan, jf);
}

RMB& operator ++(RMB& rmb)
{
    RMB& s = rmb;
    s.jf++;
    if (s.jf >= 100)
    {
        s.yuan++;
        s.jf -= 100;
    }
    return rmb;
}

int main()
{
    RMB rmb1(1,60);
    RMB rmb2(2, 50);
    RMB rmb3(0,0);
    rmb3 = rmb1 + rmb2;  
    ++rmb3;
    rmb3.display();

    RMB rmb4(1.2);
    rmb4.display();

    rmb3 = 1.2 + rmb1;
    rmb3.display();

    rmb3 = 1.2 + 1.3;
    rmb3.display();

    rmb3 = rmb1 + 1.2;
    return 0;
}

那好,我们看到.我们所在的变化是a.提供了一个隐式转换构造函数, b.把友元+的重载函数的形参从引用改为了非引用(会导致效率变低).

如果我们提供 frind operator +(double, RMB&)  friend operator+(RMB&, double), friend operator+(doube, double)的话倒是不用把引用改为非引用,但是问题是会导致要写很多个重载函数.. 所以如果把引用该为非引用而引起的效率变化不太大的情况下,建议用第一种方法

--------------------------------------------------------------------------------------------------------------------------------------------------------

接下来,我们再来分析一下 重载函数+ 使用成员函数来实现的方式

先看 rmb3 = rmb1 + rmb2的情况的代码

#include<iostream>
using namespace std;

#define UINT32 unsigned int 

class RMB
{
    public:
        RMB(UINT32 d, UINT32 c);
        RMB operator +(RMB& rmb);
        RMB& operator ++();
        void display()
        {
            cout<<(yuan + jf / 100.0)<<endl;
        }

    protected:
        UINT32 yuan;    //元
        UINT32 jf;        //角分
};

RMB::RMB(UINT32 d, UINT32 c) : yuan(d), jf(c)
{
    while (jf >= 100)
    {
        yuan++;
        jf -= 100;
    }
}

RMB RMB::operator +(RMB& rmb)
{
    UINT32 newJf = jf + rmb.jf;
    UINT32 newYuan = yuan + rmb.yuan;
    return RMB(newYuan, newJf);
}

RMB& RMB::operator ++()
{
    jf++;
    if (jf >= 100)
    {
        yuan++;
        jf -= 100;
    }
    return *this;
}

int main()
{
    RMB rmb1(1,60);
    RMB rmb2(2, 50);
    RMB rmb3(0,0);
    rmb3 = rmb1 + rmb2;  
    ++rmb3;
    rmb3.display();
    return 0;
}

然后我们再来考虑考虑  一下集中情况在运算符是成员函数的情况下是否可行

rmb3 = 1.2 + rmb1 ------------------->绝对实现不了.因为1.2(double)类型中没有重载一个+号可以加上一个RMB类型

rmb3 = rmb1 + 1.2--------------------->可行,我可以重载一个 RMB& operater +(double);

rmb3 = 1.2 + 1.1------------------------>不可行.1.2+1.3是两个double类型的相加,然后把一个double类型用重载符号=赋值给rmb3.

看来,在非类对象和操作符组合的时候,成员函数实现的运算符重载和友元函数实现的运算符重载还是有区别的啊,不可不察..

ps:

//c++ 规定: = () [] ->这四种运算符必须是成员形式
//某些双目运算符在使用非成员的形式(如复数类的+,-运算符)有肯能是为了实现某些隐式转换或者成员形式无法进行的操作(例如上面的 rmb3 = 1.2+rmb1).而特意选用的非成员形式.