运算符重载之连续加

#include <iostream>
using namespace std;

class Cp
{
private:
    static int b,
        c;
    int a;
public:
    explicit Cp(int i = 0) : a(i)
    {
        cout << "调用 " << ++b << "次构造\n";
    }
    Cp operator+ (const Cp& p) const
    {
        cout << ++c << " 次调用 " << "+重载\n";
        Cp pTemp = (Cp) (p.a + a);
        return pTemp;
    }
    friend Cp operator+ (int i, const Cp& p);
    friend void operator<< (ostream& out, const Cp& p);
};
int Cp::b = 0;
int Cp::c = 0;

Cp operator+ (int i, const Cp& p)
{
    Cp pTemp = Cp(p.a + i);
    return pTemp;
}
void operator<< (ostream& out, const Cp& p)
{
    out << p.a;
}

int main()
{
    Cp p1(1);
    cout << p1 + (Cp)2 + (Cp)3 + (Cp)5 + p1;
    cout << endl;
    cout << p1 + (Cp)4;
    cout << endl;
    cout << 4 + p1 + (Cp)4 + p1;

    system("pause");
     return 0;
} 

运行结果如下：

现在单步调试，看看是如何调用这些构造和重载的；

第一次构造：留意下this->a的值，为1；这是创建对象时调用

第二次构造：this->a的值：5；这是强制类型转换时调用

、

第三次构造：this->a的值：3；这是强制类型转换时调用

第四次构造：this->a的值：2；这是强制类型转换时调用

第一次重载：留意下传进来的参数p.a的值：2

第五次构造：this->a的值：3；这是强制类型转换时调用；3就是p1 + Cp(2)的值

第二次重载：p.a的值：3

第六次构造：this->a的值：6；这是强制类型转换时调用；6就是p1 + Cp(2)  + Cp(3)的值；

第三次重载：p.a的值：5

第七次构造：this->a的值：11；这是强制类型转换时调用；11就是p1 + Cp(2)  + Cp(3) + Cp(5)的值；

第四次重载：p.a的值：1

第八次构造：this->a的值：12；这是强制类型转换时调用；11就是p1 + Cp(2)  + Cp(3) + Cp(5) + p1的值；

然后输出了结果，

从上面发现的规则：

1、先对 + 的所有非Cp类型操作数进行类型转换，顺序是从右向左；

2、进行加法运算的顺序是从左向右；

3、每进行一次加法运算都return一个临时对象，后面再进行加法时，是用这个临时对象作为左操作数；

可以在Cp类声明中加上

Cp(const Cp& p)
	{
		cout << "第 " << ++d << " 次copy构造\n";
		a = p.a;
	}static int d;//在类外初始化int Cp::d = 0;

就可以得到下面的结果：

原文地址：https://www.cnblogs.com/IvanKeller/p/10848333.html