C++拷贝构造函数

Question

我试图很好地掌握复制构造函数，并且我找到了这部分代码。

 #include<iostream>
    using namespace std;
    class A1 {
        int data;
    public:
        A1(int i = 10) :
                data(i) {
            cout << "I am constructing an A1 with: " << i << endl;
        }
        A1(const A1& a1) :
                data(a1.data) {
            cout << "I am copy constructing an A1" << endl;
        }
        ~A1() {
            cout << "I am destroying an A1 with: " << data << endl;
        }
        void change() {
            data = data * 10;
        }
    };
    class A2 {
        int data;
    public:
        A2(int i = 20) :
                data(i) {
            cout << "I am constructing an A2 with: " << i << endl;
        }
        A2(const A2& a2) :
                data(a2.data) {
            cout << "I am copy constructing an A2" << endl;
        }
        ~A2() {
            cout << "I am destroying an A2 with: " << data << endl;
        }
        void change() {
            data = data * 20;
        }
    };
    class A3 {
    public:
        A3() {
            cout << "I am constructing an A3" << endl;
        }
        A3(const A3& a3) {
            cout << "I am copy constructing an A3" << endl;
        }
        ~A3() {
            cout << "I am destroying an A3" << endl;
        }
        void change() {
            cout << "Nothing to change" << endl;
        }
    };
    class A {
        A1 a1;
        A2 a2;
        A3 a3;
    public:
        A() {
            cout << "I am constructing an A" << endl;
        }
        A(const A& a) :
                a1(a.a1) {
            cout << "I am copy constructing an A" << endl;
        }
        ~A() {
            cout << "I am destroying an A" << endl;
        }
        A& operator=(const A& a) {
            cout << "I am performing a stupid assignment between As" << endl;
            if (this != &a)
                a1 = a.a1;
            return *this;
        }
        void change() {
            a1.change();
            a2.change();
            a3.change();
        }
    };
    class BigA {
        A data1;
        A& data2;
    public:
        BigA(A& a) :
                data1(a), data2(a) {
            cout << "I just constructed a BigA" << endl;
        }
        ~BigA() {
            cout << "I am destroying a BigA" << endl;
        }
        A get(int index) {
            if (index == 1)
                return data1;
            else
                return data2;
        }
    };
        BigA volta(BigA& biga)
     //BigA& volta(BigA& biga)
            {
        cout << "Volta ta data?" << endl;
        return biga;
    }
    int main() {
        A first;
        BigA biga(first);
        volta(biga).get(2).change();
        return 0;
    }

但是，我不明白为什么我得到这些 results.Especially，为什么调用 A1 和 A 复制构造函数而不是构造函数，并且在调用 volta 函数时我根本没有得到（附上的结果通过 ****）：

I am constructing an A1 with: 10
I am constructing an A2 with: 20
I am constructing an A3
I am constructing an A
I am copy constructing an A1
I am constructing an A2 with: 20
I am constructing an A3
I am copy constructing an A
I just constructed a BigA
****
Volta ta data?
I am copy constructing an A1
I am constructing an A2 with: 20
I am constructing an A3
I am copy constructing an A
I am copy constructing an A1
I am constructing an A2 with: 20
I am constructing an A3
I am copy constructing an A
Nothing to change
I am destroying an A
I am destroying an A3
I am destroying an A2 with: 400
I am destroying an A1 with: 100
I am destroying a BigA
I am destroying an A
I am destroying an A3
I am destroying an A2 with: 20
I am destroying an A1 with: 10
****
I am destroying a BigA
I am destroying an A
I am destroying an A3
I am destroying an A2 with: 20
I am destroying an A1 with: 10
I am destroying an A
I am destroying an A3
I am destroying an A2 with: 20
I am destroying an A1 with: 10

EDIT_AssignmentOperatorQuery : 如果我在 BigA

中添加这个函数

void change() {
    A& rdata1 = data1;
    A cdata2 = data2;
}

并从 main 调用它：biga.change(); 为什么调用复制构造函数和构造函数而不是默认赋值运算符，我得到

I am copy constructing an A1
I am constructing an A2 with: 20
I am constructing an A3
I am copy constructing an A

EDIT_AnsweringMyOwnQuery : 我刚刚发现这是通过复制构造函数初始化而不是通过赋值运算符赋值。

Answer 1

让我们开始吧。

`A first;`

你创建了一个对象，它的字段（非静态成员）被初始化

"Before the compound statement that forms the function body of the constructor begins executing, initialization of all direct bases, virtual bases, and non-static data members is finished."

I am constructing an A1 with: 10
I am constructing an A2 with: 20
I am constructing an A3

并且正在调用您的无参数构造函数版本：

I am constructing an A

写的时候

`BigA biga(first);`

您的一个 BigA 构造函数被调用。它需要对 A 对象的引用，因此 first 不会被复制（在提供值时设置引用）。

然后，成员初始化列表时间到了，

BigA(A& a) :
            data1(a), data2(a)

和data1是A类型，first对象被复制（这里引用为a）

一个新的A对象由它自己的复制构造函数创建。首先，它调用 A1、

的复制构造函数

A(const A& a) :
a1(a.a1)

I am copy constructing an A1

然后，A 的 a2 和 a3 字段被默认初始化。

I am constructing an A2 with: 20
I am constructing an A3

然后执行 A1 的复制构造函数主体：

I am copy constructing an A

让我们return对BigA进行初始化。到现在为止我们谈到了 data1 初始化，现在是 A& data2:

的时候了

BigA(A& a) :
            data1(a), data2(a)

因为它是引用，并且传递引用来初始化它，所以它只是一个赋值，没有输出。

BigA 构造函数（需要 A&）然后执行主体：

I just constructed a BigA

现在，我们将尝试澄清

上发生的事情

`volta(biga).get(2).change();`

正在调用此函数：

BigA volta(BigA& biga)
{
    cout << "Volta ta data?" << endl;
    return biga;
}

同样，通过引用传递不会调用复制构造函数。

我们正在执行函数体：

"Volta ta data?"

函数return是classBigA的未命名对象，所以应该调用拷贝构造函数。

您没有像 BigA (const BigA & biga) 那样提供复制构造函数，因此正在调用 默认复制构造函数 。它依次对 A data1; 和 A& data2;

进行成员初始化

第一个成员通过复制未命名对象的 data1 字段来初始化，因此正在调用 A 的复制构造函数。这里打印的内容上面有解释（参见：A new A object is created by its own copy constructor...）

I am copy constructing an A1
I am constructing an A2 with: 20
I am constructing an A3
I am copy constructing an A

然后，get 方法运行 index == 2

A get(int index) {
        if (index == 1)
            return data1;
        else
            return data2; // <--- this line is executed

data2是A&，方法return是A，这导致A拷贝构造函数执行

I am copy constructing an A1
I am constructing an A2 with: 20
I am constructing an A3
I am copy constructing an A

最后，change 运行

void change() {
        a1.change();
        a2.change();
        a3.change();
    }

并且只有 a3.change() 打印了一些东西：

Nothing to change

程序终止时

销毁顺序相反，最后创建的change对象最先销毁。

I am destroying an A
I am destroying an A3
I am destroying an A2 with: 400
I am destroying an A1 with: 100

I am destroying a BigA 被打印了两次，但是 I just constructed a BigA - 只打印了一次。后者是因为你没有 BigA 的复制构造函数，它需要 const & BigA （上面也指出了）。

正在回答您的问题

void change() {
    A& rdata1 = data1;
    A cdata2 = data2;
}
//in the main():
biga.change();

是的，你说得对，这里会调用复制构造函数 A cdata2 = data2;，因为对象 cdata2 之前未初始化。这种情况很好解释under this ref.

如果你这样修改代码

A cdata2;
cdata2 = data2;

您会看到预期的分配：

I am constructing an A1 with: 10
I am constructing an A2 with: 20
I am constructing an A3
I am constructing an A
I am performing a stupid assignment between As

C++拷贝构造函数

C++ copy costructor

c++

copy-constructor

copy-assignment

`A first;`

`BigA biga(first);`

`volta(biga).get(2).change();`

程序终止时

正在回答您的问题