在 C++ 中的基类销毁期间是否可以知道派生实例类型？

Question

假设我有来自A 的纯类A 和B、C、D 等。是否可以从A 的析构函数中知道哪个派生类正在被销毁？

Answer 1

这取决于你需要什么。人们当然会在这里质疑为什么，这是一个值得怀疑的愿望。

在编译时不可能随时从基类中自动知道对象的动态类型。如果您想在编译时知道类型，唯一的解决方案是将该信息包含在基类类型本身中，这基本上是 CRTP 模式。例如：

class BaseBase {
    // body
};

template <typename D>
class Base : BaseBase {
    //body
};

class Derived1 : public Base<Derived1> {
    // body
};

class Derived2 : public Base<Derived2> {
    // body
};

这样Base 的析构函数将在编译时“知道”派生类的类型。然而，这有一个缺点，Derived1 和 Derived2 的常见超类型 不是 Base，但 BaseBase 和 BaseBase 析构函数无法知道（你可能会回来第一广场）。

如果您只想在运行时知道（这意味着您不能直接执行 DerivedClass::something 之类的操作），例如出于调试原因，您可以在包含类型信息的基类中添加一个成员：

class Base {
protected:
     type_info const* type;

public:
    Base() {
        type = &typeid(this);
    }
};

class Derived : public Base {
public:
     Derived() {
          type = &typeid(this);
     }
};

请注意，这依赖于 Base 构造函数将在 Derived 构造函数之前运行这一事实，因此 type 指针将引用当前已构造的最派生类。

Answer 2

使用CRTP时可以这样做，像这样：

template <typename TDerived>
class Base {};

class Derived : public Base<Derived> {};

那么Base 始终知道派生类型。

Answer 3

CRTP 的问题在于您有不同的基本类型，不能用于动态多态性。

如果您不需要派生对象的实际类型，但想根据它执行代码，则有不同的可能性。请注意，您不能在析构函数中调用任何虚函数。但是，您可以：

1。添加一个类型成员变量（可以是std::type_info、枚举或其他）并手动对其进行调度。

2。使用一种技术作为virtual constructor idiom 的对应技术，在显式销毁之前调用一个函数（通过delete 或类似方法）。但是，这要么被遗忘，要么（如果强制执行）严重限制了您销毁对象的方式。

3。您可以使用策略模式：

class Base
{
    struct Strategy
    { 
        virtual ~Strategy();
        virtual void onDestroy() = 0;
    }

    std::unique_ptr<Strategy> strategy;

public:
    explicit Base(std::unique_ptr<Strategy> strategy)
    : strategy(std::move(strategy))
    {
    }

    virtual ~Base()
    {
        strategy->onDestroy();
    }
};

class Derived1 : public Base
{
    struct Strategy1 : Strategy
    {
        virtual void onDestroy() { ... }
    };

public:
    Derived1()
    : Base(std::make_unique<Strategy1>())
    {
    }
};

注意，使用 C++11 函数对象，这变得相当简单：

class Base
{
    std::function<void()> strategy;

public:
    explicit Base(std::function<void()> strategy)
    : strategy(std::move(strategy))
    {
    }

    virtual ~Base()
    {
        strategy();
    }
};

class Derived1 : public Base
{
public:
    Derived1()
    : Base([] () { ... })
    {
    }
};

重要提示：您必须确保策略对象或函数对象不引用派生类的任何成员，因为派生对象在调用时已被销毁。如果需要访问成员属性，最好直接重新定义析构函数。