C++ 当构造函数必须创建其他类的新对象时，它是如何工作的？

我有一段代码，我正试图理解编译器是如何工作的：

#include <iostream>
using namespace std;
class Block
{
    int data;

public:
    Block(int i = 10)
        : data(i)
    { 
        cout << "I just created a Block " << endl;
    }
    ~Block()
    {
        cout << "I will destroy a Block with " << data << endl;
    }
    void inc()
    {
        data++;
    }
};
class A
{
    Block& block1;
    Block block2;

public:
    A(Block& blk)
        : block1(blk)
        , block2(blk)
    {
        cout << "I just created an A " << endl;
    }
    A(const A& a)
        : block1(a.block1)
        , block2(a.block2)
    {
        cout << "I just created an A by copying but I will also do bad things" << endl;
        block1.inc();
        block2.inc();
    }
    ~A()
    {
        cout << "I will destroy an A " << endl;
    }
    void inc()
    {
        block1.inc();
        block2.inc();
    }
};
class Fat
{
    A a;
    A& ra;
    A* pa;

public:
    Fat(A& da)
        : a(da)
        , ra(da)
    {
        pa = new A(da);
        cout << "Fat just created !" << endl;
    }
    ~Fat()
    {
        delete pa;
        cout << "Fat to be destroyed !" << endl;
    }
    void inc()
    {
        a.inc();
        ra.inc();
        pa->inc();
    }
};
int main()
{
    Block block;
    A a(block);
    Fat fat(a);
    fat.inc();
    return 0;
}

---

您可以用更简单的代码来演示这一点

#include <iostream>

class Noisy
{
public:
    Noisy()
        { std::cout << "Noisy default construct\n"; }
    ~Noisy()
        { std::cout << "Noisy destroy\n"; }
};

int main()
{
    Noisy noisy1;
    Noisy noisy2(noisy1);
}

如果我们自己定义复制构造函数

#include <iostream>

class Noisy
{
public:
    Noisy()
        { std::cout << "Noisy default construct\n"; }
    Noisy(Noisy const&)
        { std::cout << "Noisy copy construct\n"; }
    ~Noisy()
        { std::cout << "Noisy destroy\n"; }
};

int main()
{
    Noisy noisy1;
    Noisy noisy2(noisy1);
}

#包括
课堂噪音
{
公众：
嘈杂的
{std:：cout
当它创建对象时，是创建新块还是使用现有块？为什么不运行块的构造函数

查看
A
构造函数：

A(Block& blk)
        : block1(blk)
        , block2(blk)
    {
    }

block1
是
Block
对象的一个变量。因此它引用已经创建的
blk
变量，并且不会创建另一个变量。因此在这种情况下不会调用构造函数

对于不是引用的
block2
，情况并非如此。在这种情况下，确实会创建一个新对象
Block
，但使用

在
块
类中定义的是默认构造函数。
当从同一类的另一个对象开始创建类实例时，将调用复制构造函数（注意：不是默认构造函数）

复制构造函数由编译器隐式定义，除非您自己定义一个

例如：

class Block {
 public:
   Block(const Block& other) : data(oth.data) {
     std::cout << "Invoked copy 'ctor" << std::endl;
   }

   // ... other stuff
};

类块{
公众：
块（常量块和其他）：数据（其他数据）{
std:：cout你有什么具体的疑问吗？引用是引用，值对象不是，并且会被复制。“为什么不运行block的构造函数？”你只调用了一次
block block；
，它就这样做了：
我刚刚创建了一个block
block1和block2会有什么？@πάνταῥεῖ 请不要用“怀疑”代替“问题”。你是德国人，不是印度人！@Lightness我不太确定我现在是什么：P
#include <iostream>

class Noisy
{
public:
    Noisy()
        { std::cout << "Noisy default construct\n"; }
    Noisy(Noisy const&)
        { std::cout << "Noisy copy construct\n"; }
    ~Noisy()
        { std::cout << "Noisy destroy\n"; }
};

int main()
{
    Noisy noisy1;
    Noisy noisy2(noisy1);
}

Noisy default construct
Noisy copy construct
Noisy destroy
Noisy destroy
A(Block& blk)
        : block1(blk)
        , block2(blk)
    {
    }

class Block {
 public:
   Block(const Block& other) : data(oth.data) {
     std::cout << "Invoked copy 'ctor" << std::endl;
   }

   // ... other stuff
};