运算符重载的例子不清楚

Operator overloading example not clear

本文关键字：不清楚 重载 运算符      更新时间：2023-10-16

我正在学习操作符重载，我发现了这个例子:

#include <iostream>
using namespace std;
class MinMax
{
private:
    int m_nMin; // The min value seen so far
    int m_nMax; // The max value seen so far
public:
    MinMax(int nMin, int nMax)
    {
        m_nMin = nMin;
        m_nMax = nMax;
    }
    int GetMin() { return m_nMin; }
    int GetMax() { return m_nMax; }
    friend MinMax operator+(const MinMax &cM1, const MinMax &cM2);
    friend MinMax operator+(const MinMax &cM, int nValue);
    friend MinMax operator+(int nValue, const MinMax &cM);
};
MinMax operator+(const MinMax &cM1, const MinMax &cM2)
{
    // Get the minimum value seen in cM1 and cM2
    int nMin = cM1.m_nMin < cM2.m_nMin ? cM1.m_nMin : cM2.m_nMin;
    // Get the maximum value seen in cM1 and cM2
    int nMax = cM1.m_nMax > cM2.m_nMax ? cM1.m_nMax : cM2.m_nMax;
    return MinMax(nMin, nMax);
}
MinMax operator+(const MinMax &cM, int nValue)
{
    // Get the minimum value seen in cM and nValue
    int nMin = cM.m_nMin < nValue ? cM.m_nMin : nValue;
    // Get the maximum value seen in cM and nValue
    int nMax = cM.m_nMax > nValue ? cM.m_nMax : nValue;
    return MinMax(nMin, nMax);
}
MinMax operator+(int nValue, const MinMax &cM)
{
    // call operator+(MinMax, nValue)
    return (cM + nValue);
}
int main()
{
    MinMax cM1(10, 15);
    MinMax cM2(8, 11);
    MinMax cM3(3, 12);
    MinMax cMFinal = cM1 + cM2 + 5 + 8 + cM3 + 16;
    cout << "Result: (" << cMFinal.GetMin() << ", " <<
        cMFinal.GetMax() << ")" << endl;
    return 0;
}

我不明白MinMax cMFinal = cM1 + cM2 + 5 + 8 + cM3 + 16;这行是怎么工作的。

计算后，它变成了MinMax cMFinal = MinMax(3, 16)。接下来会发生什么?当我没有定义重载赋值操作符时，编译器如何将一个对象赋值给另一个对象?

假设您有两个MinMax对象，a和b。然后当你有像

这样的行
MinMax c = a + b;

然后编译器将其翻译成下面的

MinMax c = operator+(a, b);

换句话说，它就像一个普通的函数调用。

如果执行多个操作，如

MinMax d = a + b + c;
那么编译器将在内部生成临时变量并使用，如 
MinMax compilerGeneratedTemporary = operator+(a, b);
MinMax d = operator+(compilerGeneratedTemporary, c);

如果您想知道的是初始化，那么它正在调用MinMax 复制构造函数。当你同时声明和初始化一个对象变量时，它不是赋值，它只是重用赋值操作符。

operator+函数返回一个MinMax对象，该对象传递给类的复制构造函数。

如果一个类没有复制构造函数，编译器会自动为你生成一个(有一些例外，参见下面链接的参考)。

相关文章：