我不明白这个例子中什么时候调用了构造函数

Question

您好，我一直在尝试分析以下使用操作重载的代码。

#include <iostream>
using namespace std;

#define DBG(str) cout << str << endl

class Integer {
    int n;
public:
    Integer(int _n) : n(_n) { DBG("A"); };
    Integer(const Integer& i) : n(i.n) { DBG("B"); };

    Integer& operator=(const Integer& i) { DBG("C"); n = i.n; return *this; };
    Integer& operator+=(const Integer& i) { DBG("D"); n += i.n; return *this; };

    friend Integer operator+(const Integer& a, const Integer& b);
    friend Integer operator*(const Integer& a, const Integer& b);
    friend ostream& operator<<(ostream& os, const Integer& i);

};

Integer operator+(const Integer& a, const Integer& b) {
    DBG("E"); return Integer(a.n + b.n);
}
Integer operator*(const Integer& a, const Integer& b) {
    DBG("F"); return Integer(a.n * b.n);
}
ostream& operator<<(ostream& os, const Integer& i) {
    DBG("G"); os << i.n; return os;
}

int main() {
    Integer n1(1), n2(2);
    Integer n = 5 + n1 + 2 * n2;

    cout << n << endl;
}

结果是……

A // constructor called when n1 is created
A // constructor called when n2 is created
A // when is this called?
A // when is this called?
F // called when 2 * n2 is operated
A // called when Integer(a.n * b.n) is created in the multiplication function
E // called when 5 + n1 is operated
A // called when Integer(a.n + b.n) is created in the addition function
E // called when (5 + n1) + (2 * n2) is operated
A // called when Integer is created in the addition function
G // called when n is printed using cout
5 // value of n

现在我最麻烦的是A的第三和第四个打印。在Integer n = 5 + n1 + 2 * n2;这句话中，对象n正在被创建并且正确的值被分配给n，所以应该调用一个复制构造函数?我认为应该发生的是应该调用构造函数来制作(5 + n1 + 2 * n2) 的临时对象，然后通过将其复制到n，应该调用复制构造函数。我理解错了什么？

你能解释一下发生了什么吗？提前谢谢你。

Answer 1

问题出在这一行：

Integer n = 5 + n1 + 2 * n2;

对于int 和Integer 没有operator+，但编译器默默地从int 到Integer 做了一个implicit conversion，因为默认情况下所有单参数构造函数都可以用作转换方法。 这里是your live code（稍微改进了一点）。

这是 C++ 的危险特性之一，因此在构造函数之前要使用 explicit 关键字。如果你添加它：

explicit Integer(const Integer& i) : n(i.n) { DBG("B"); };

编译器将报告错误，因为现在无法执行隐式转换并且没有operator+(int, const Integer&) 和operator*(int, const Integer&)。

Answer 2

您的operator+ 和operator* 函数接收const Integer& 作为参数。

计算此行时 (5 + n1 + 2 * n2) 5 和 2 将自动转换为 Integer。

如果您不希望它们被转换，您应该考虑为int 创建运算符作为参数。

编辑：您也可以使用显式构造函数。

例如：explicit Integer(int _n){...}

//感谢@foreknownas_463035818的评论

Answer 3

Friend 函数仅在运算符函数的第一个参数不是为其定义运算符函数的目标类的对象时才用于运算符重载。 在你的情况下，Integer:

Integer operator+(const Integer& a, const Integer& b) {
    DBG("E"); return Integer(a.n + b.n);
}
Integer operator*(const Integer& a, const Integer& b) {
    DBG("F"); return Integer(a.n * b.n);
}

，第一个参数确实是Integer 类型的对象，它是您的目标类。您可能想要的是能够将您的 Integer 对象与原始整数类型一起用作操作数。 将您的朋友函数签名更改为：

Integer operator+(const int& a, const Integer& b) {
    DBG("E"); return Integer(a + b.n);
}
Integer operator*(const int& a, const Integer& b) {
    DBG("F"); return Integer(a * b.n);
}

请注意，a 用于代替 a.n，因为当运算符函数被定义为友元时，两个操作数都作为参数传递。（与第一个操作数是调用对象的非友元运算符函数不同）。所以a 包含int 类型的值，而不是Integer 类型的值。

对包含DBG("A") 的构造函数的匿名调用是5 和2 从int 转换为Integer 时发生的隐式转换的结果。

尽管您的代码可能有效，但这是不可靠的。 希望这会有所帮助。