Question

今天我的问题是，为什么在没有用户提供的赋值运算符的情况下调用构造函数？我知道与=符号有关的构造函数和赋值运算符之间的区别。如果该行之前不存在对象，则将隐式调用构造函数。

std::string name = "Bjarne"; // implicit constructor

如果该行之前已经存在一个对象，则将调用赋值运算符。

std::string name;
name = "Bjarne";   // assignment operator

现在我在这里有一个class Number，它是一个标记的联合。它只是一个数字，表示int或float。我定义了多个转换构造函数，这些转换构造函数使用户可以轻松地将值隐式分配给Number。我希望在这种情况下可以打电话给他们：

Number num1 = 8;

为了确定何时调用哪个构造函数，我将print语句放在构造函数的主体中。

#include <cstdlib>
#include <iostream>

using std::cin;
using std::cout;
using std::cerr;
using std::endl;
using std::ostream;


/* Unions can be anonymous (unnamed).
 * This form is used when nesting a union inside a struct or class that contains an extra data member
 * to indicate what the union contains.
 * This arrangement is called a tagged union (or managed union).
 * It can be used as a "polymorphic" class which can be several things at once, for example to create an array
 * of different data types.
 */

class Number {
    friend ostream& operator<<(ostream& os, Number& num);
  public:
    Number(int i = 0) : DATA_TYPE(INTEGER), i(i) { cerr << "Number(" << i << ")\n"; }

    Number(unsigned int u) : DATA_TYPE(INTEGER), i(static_cast<int>(u)) { cerr << "Number((signed) " << i << ")\n"; }

    Number(float f) : DATA_TYPE(FLOAT), f(f) { cerr << "Number(" << f << ")\n"; }

    Number(double d) : DATA_TYPE(FLOAT), f(static_cast<float>(d)) { cerr << "Number((float) " << f << ")\n"; }    

    Number(const Number& rhs) : DATA_TYPE(rhs.DATA_TYPE), i(rhs.i) { cerr << "Number((Number) " << *this << ")\n"; }
  private:
        enum data_type { INTEGER, FLOAT } DATA_TYPE;

    union {
        int i;
        float f;
    };
};


ostream& operator<<(ostream& os, Number& num)
{
    switch (num.DATA_TYPE) {
        case Number::INTEGER:
      cout << num.i;
          break;
        case Number::FLOAT:
      cout << num.f;
          break;
    default:
      cout << 0;
      break;
    }

    return os;
}


int main()
{
    Number num1 = 5;  // conversion constructor
    cout << num1 << endl;
    num1 = 12.5;
    cout << num1 << endl;

    return EXIT_SUCCESS;
}

当我运行此代码时，它将为我产生意外的输出：

Number(5)
5
Number((float) 12.5)
12.5

我看到初始化Number num1时，会调用以int作为参数的构造函数。然后，我打印num1的值。然后在下一行似乎调用了以double作为参数的构造函数。这很奇怪。在该行之前，num1已作为对象存在。因此，它应该在逻辑上调用赋值运算符。我没有定义任何赋值运算符，因此我假设将调用由编译器生成的赋值运算符。

我想知道，在没有用户提供的赋值运算符的情况下，当我这样做时会发生什么？ num1 = something;是调用编译器提供的默认赋值运算符还是调用构造函数？在已经存在的对象上调用构造函数时会发生什么？该对象是否被“重建”？那么在那种情况下实际发生了什么？

Answer 1

我想知道，在没有用户提供的赋值运算符的情况下，当我执行此num1 = something;时会发生什么？

num1 = 12.5;

调用隐式Number::operator =(const Number&)。

因此从double构造一个临时数字。

是调用编译器提供的默认赋值运算符还是调用构造函数？

两者。构造函数是为临时对象而不是现有对象调用的。

在已经存在的对象上调用构造函数时会发生什么？该对象是否得到“重建”？那么在那种情况下实际发生了什么？

您无法在现有对象上调用构造函数。您可以做的最接近的事情是placement-new。

Answer 2

感谢Jarod42，我知道了。因此，正如他建议的那样，在scrape = True的右侧不可见地构造了一个临时Number对象，然后调用了赋值运算符，并在该行的末尾销毁了该临时对象。

我将以下代码添加到=类中，以实际查看正在发生的情况。

Number

使用此Number& operator=(const Number& rhs) { cerr << "operator=(const Number&)" << endl; return *this; } ~Number() { cerr << "~Number()" << endl; }函数

main()

产生以下输出：

int main()
{
    Number num1 = 5;
    num1 = 12.5;

    cout << endl;

    Number num2 = 8;
    num1 = num2;

    return EXIT_SUCCESS;
}

为什么在没有赋值运算符的情况下调用转换构造函数？

2 个答案: