Question

我有一个基本而简单的问题。

我有这种情况：

#include <iostream>
using namespace std;

class Inner1
{
public:
    ~Inner1() {cout << "Inner1 Des\n";};
};

class Inner2
{
public:
    ~Inner2() {cout << "Inner2 Des\n";};
};

class Base
{
public:
    ~Base() {cout << "Base Des\n";};

    Inner1 inner1;
    Inner2 inner2;
};

int main() {
    Base base;
    return 0;
}

我的控制台现在告诉我：

基础析构函数称为 Inner2析构函数称为 Inner1析构函数叫

这是正常行为吗？因为某些功能的功能
已经在我的基类析构函数中销毁，而内部类依赖在他们身上。

不推荐的解决方法：

只需添加＆＃34;驱逐舰＆＃34;在第一个位置使用对象的类：

[...]
class Base
    {
    public:
        ~Base() {cout << "Base Des\n";};

        class Destroyer
        {
             ~Destroyer()
             {
                 //Put the stuff here because this destr will be called last
                 cout << "Destroyer Des\n";
             }
        } _destroyer;
        Inner1 inner1;
[...]

感谢您的帮助

Answer 1

使用此代码：

#include <iostream>

class Base
{
    public:
        class Sub1
        {
            public:
                Sub1()
                {
                    std::cout << "Base::Sub1::Constructed\n";
                }
                ~Sub1()
                {
                    std::cout << "Base::Sub1::Destroyed\n";
                }
        };
        class Sub2
        {
            public:
                Sub2()
                {
                    std::cout << "Base::Sub2::Constructed\n";
                }
                ~Sub2()
                {
                    std::cout << "Base::Sub2::Destroyed\n";
                }
        };


        Sub1    sub1;
        Sub2    sub2;
        Base()
        {
            std::cout << "Base::Constructed\n";
        }
        ~Base()
        {
            std::cout << "Base::Destroyed\n";
        }
};

int main()
{
    Base    base;
}

我得到（手动添加评论）

> ./a.out
// Build all members first in the order they are declared.
Base::Sub1::Constructed
Base::Sub2::Constructed
// Call the constructor of the object
Base::Constructed

// Destruction happens in revers.
// Calls the destructor code to handle all local resources
Base::Destroyed
// Then destroy all members in reverse order of declaration
Base::Sub2::Destroyed
Base::Sub1::Destroyed

Answer 2

这是正常行为吗？

是。子对象析构函数由容器类的析构函数调用。特别是，在执行容器类析构函数的主体之后，子对象将被销毁。

因为某些功能的功能已经在我的Base类析构函数中被销毁，而Inner类依赖于它们。

如果内部类[sic]析构函数依赖于包含它们的Base实例，那么这只是一个问题。在这种情况下，Base不应将它们包含为成员，或者它们的析构函数不应该依赖Base。

Answer 3

类成员按照它们在类中定义的顺序构造。这意味着，

class Demonstration
{
    XClass x;
    YClass y;
};

在上面的示例中，x将在y之前构建。由于破坏以相反的构造顺序发生，y将始终在x之前被破坏。

在Base类析构函数之后调用内部类析构函数

3 个答案: