为什么要调用复制操作员？

Question

在最后一行myA = foo(myOtherB);，函数将返回类型为A的对象，因此；这就像说`myA = input，但是为什么是复制构造函数呢？

输出：

B foo()
 A copy ctor //what calls this?
 A op=

要调用复制构造函数，我们必须在初始化期间使用赋值运算符，例如：B newB = myOtherB;

#include <iostream>
using namespace std;

class A {
public:
 A() { cout << "A ctor" << endl; }
 A(const A& a) { cout << "A copy ctor" << endl; }
 virtual ~A() { cout << "A dtor" << endl; }
 virtual void foo() { cout << "A foo()" << endl; }
 virtual A& operator=(const A& rhs) { cout << "A op=" << endl; }
};

class B : public A {
public:
 B() { cout << "B ctor" << endl; }
 virtual ~B() { cout << "B dtor" << endl; }
 virtual void foo() { cout << "B foo()" << endl; }
 protected:
 A mInstanceOfA; // don't forget about me!
};

A foo(A& input) {
 input.foo();
 return input;
}
int main() {
 B myB;
 B myOtherB;
 A myA;
 myOtherB = myB;
 myA = foo(myOtherB);
}

Answer 1

在最后一行myA = foo(myOtherB);，函数将返回类型为B的对象

不正确。您的函数按值返回 A 类型的对象。这意味着，您为这个对象提供的任何值都将用于构造该确切类型的新对象。换句话说：

int foo(float a) {
    return a + 0.5;
}

int u;

u = foo(9.3);

// u has a value of 10

不要指望u 持有 int 不能保存的值。

如果你使用用户定义的类型也是一样的：

A foo(A& input) {
 input.foo();
 return input; // this expression returns a new A
               // using the value of `input`
}

A myA;

myA = foo(myOtherB);

// why would `myA` be anything else than the value of an A?

---

那么，这里发生了什么？

B foo()
 A copy ctor //what calls this?
 A op=

A foo(A& input) {
 input.foo(); // prints B foo, virtual call. a reference to A that
              // points to an object of subclass type B

 return input; // copy `input` into the return value object
}

然后，operator= 被调用。

Answer 2

见cppreference

具体来说：

每当一个对象从同类型的另一个对象初始化（通过直接初始化或复制初始化）时，都会调用复制构造函数（除非重载决议选择了更好的匹配或省略了调用），这包括

• 初始化：T a = b;或 T a(b);，其中 b 是 T 类型；
• 函数参数传递：f(a);，其中 a 是 T 类型，f 是 void f(T t);
• 函数返回：返回一个；在诸如 T f() 之类的函数中，其中 a 的类型为 T，它没有移动构造函数。