什么是的顺序析构和构造是所谓的C++

Question

什么是的顺序析构和构造是所谓的C++？使用的例子的一些基类和源类别

Answer 1

顺序是：

1. 基本构造
2. 衍生的构造
3. 衍生析构
4. 基析构

例如：

class B
{
public:
  B()
  {  
    cout<<"Construct B"<<endl;
  }

  virtual ~B()
  {
    cout<<"Destruct B"<<endl;
  }
};

class D : public B
{
public:
  D()
  {  
    cout<<"Construct D"<<endl;
  }

  virtual ~D()
  {
    cout<<"Destruct D"<<endl;
  }
};



int main(int argc, char **argv)
{
  D d; 
  return 0;
}

输出的例子：

建造B

建造D

毁D

毁B

多层次的继承就像一个堆栈：

如果你考虑推动一个项目栈作为建设，并把它作为销毁，然后你可以看看在多个级别的继承像堆。

这适用于任何数量的水平。

例D2源从D来自B。

推B上叠，推D叠，推D2上堆。因此建造了是B、D、D2。然后找到了破坏了开始大跌眼镜。D2,D,B

更复杂的例子：

对于更复杂的例子，请参阅提供的链接，通过@JaredPar

Answer 2

这些事件，包括虚拟和多重继承的详细描述可在C ++ FAQ精简版。部25.14 25.15和

https://isocpp.org/wiki/faq/多继承＃MI-VI-构造函数-订单

Answer 3

另外，请注意，尽管阵列元件被第一构造 - >最后，它们被按相反的顺序破坏：最后 - >第一

Answer 4

我必须添加到以前的答案，因为每个人似乎都忽略它

当你有一个 衍生的 类实例 创建, 它是真实的，该代码 内部 构造的 基地 将被称为 之前 代码 内部 构造的 衍生的, 但请记住， 衍生的 仍然是技术上 "创建的" 之前 的 基地.

当你拥有的 衍生的 类析构，它是真实的，该代码 内部 该衍生析构被称为 之前 代码 内部 基析构，但也记住， 基地 是 摧毁了 之前 的 衍生的.

当我说 创建/销毁 实际上我参考 分配/释放.

如果你看看记忆的布局，这些情况中，你会看到的源的实例 组成 基的实例。例如：

存储器的导：0x00001110到0x00001120

存储的基础：0x00001114到0x00001118

因此，得出类必须分配 之前 基于建设。和源类必须被释放 后 基于破坏。

如果你有下列代码：

class Base 
{
public:
    Base()
    {
        std::cout << "\n  Base created";
    }
    virtual ~Base()
    {
        std::cout << "\n  Base destroyed";
    }
}

class Derived : public Base 
{
public:
    Derived()
    // Derived is allocated here 
    // then Base constructor is called to allocate base and prepare it
    {
        std::cout << "\n  Derived created";
    }
    ~Derived()
    {
        std::cout << "\n  Derived destroyed";
    }   
    // Base destructor is called here
    // then Derived is deallocated
}

所以如果你创造了 Derived d; 并已超出范围，然后你会得到输出@布莱恩的答复。但对象的行为的记忆不是真的在相同的顺序，更是这样的：

建设：

1. 衍生分配

2. 基地分配

3. 基本构造所谓

4. 衍生的构造所谓

破坏：

1. 衍生析构称

2. 基析构称

3. 基释放

4. 衍生的释放