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

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

现在我的控制台告诉我：

Base destructor called
Inner2 destructor called
Inner1 destructor called

这是正常行为吗？因为某些功能的功能
已经在我的 Base Class 析构函数和内部 classes 中销毁了在他们身上。

不推荐的解决方法：

只需在第一个位置添加一个 "Destroyer" class with object:

[...]
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

Is this the normal behavior?

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

Because the functionality for some functions is already destroyed in my Base Class destructor and the Inner classes rely on them.

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

Answer 3

Class 成员按照它们在 class 中定义的顺序构造。也就是说，

class Demonstration
{
    XClass x;
    YClass y;
};

在上面的示例中，x 将在 y 之前构造。由于销毁以相反的构造顺序发生，y 将始终在 x.

之前被销毁

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

Inner class destructor is called after Base class destructor

c++

c++11

destructor