1

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

 #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;
    }

但是，我不明白为什么会得到这些结果。特别是，为什么调用 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 ：我刚刚发现这是复制构造函数的初始化，而不是赋值运算符的赋值。

4

1 回答 1

1

让我们从它开始。

A first;

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

“在构成构造函数的函数体的复合语句开始执行之前，所有直接基、虚拟基和非静态数据成员的初始化都已完成。”

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'sa2和a3字段被默认初始化。

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

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

I am copy constructing an A

让我们回到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?"

该函数返回类的未命名对象BigA，因此应调用复制构造函数。

您还没有提供类似的复制构造函数BigA (const BigA & biga)，因此正在调用默认的复制构造函数。它执行顺序成员初始化，A data1;然后A& data2;

第一个成员是通过复制未命名对象的字段来初始化的，因此正在调用data1复制构造函数。A上面解释了这里打印的内容（参见：A new Aobject 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

data2is A&，并且方法返回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的 'd 对象首先被销毁。

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先前未初始化，所以将在此处调用复制构造函数。在此参考文献中很好地解释了这种情况。

如果您像这样更改代码

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
于 2016-02-08T11:50:04.673 回答