有没有可能颠倒毁灭的顺序

Is it possible to invert order of destruction?

本文关键字：毁灭 顺序 有可能      更新时间：2023-10-16

我有一个实现许多基本功能的基类，它需要一些"存储"(内存块)，必须由继承它的类(或用户)提供。

class Base
{
public:
    Base(void* storage, size_t storageSize) :
        storage_{storage},
        storageSize_{storageSize}
    {
        // do something with the storage...
    }
    ~Base()
    {
        // do something with the storage...
    }
    // member functions
private:
    void* storage_;
    size_t storageSize_;
};
这里需要注意的是，这个内存块是在构造函数和析构函数中使用的。

当子类使用静态存储时，这非常有效:

template<size_t Size>
class StaticObject : public Base
{
public:
    StaticObject() :
        Base{&storage, Size}
    {
    }
private:
    typename std::aligned_storage<Size>::type staticStorage_;
};

我知道存储在构造之前(它在Base的构造函数完成之后被"构造")和在它被销毁之后(它在Base的析构函数开始运行之前被"销毁")使用，但是对于平凡的std::aligned_storage<...>::type，这没有什么区别。

然而，当我想在动态分配的存储中使用它时，这个想法完全失败了:

class DynamicObject : public Base
{
public:
    DynamicObject(size_t size) :
        DynamicObject{std::unique_ptr<uint8_t>{new uint8_t[size]}, size}
    {
    }
private:
    DynamicObject(std::unique_ptr<uint8_t>&& dynamicStorage, size_t size) :
        Base{dynamicStorage.get(), size},
        dynamicStorage_{std::move(dynamicStorage)}
    {
    }
    std::unique_ptr<uint8_t> dynamicStorage_;
};

正如你在委托构造函数中看到的，我设法在Base的构造函数中使用存储之前创建(分配)存储-稍微"颠倒"了构造顺序。这个特殊的阶段也工作得很好。问题是析构函数，因为我真的想不出任何解决我的问题的方法-在上面的代码中，动态分配的存储将在Base的析构函数开始运行之前被释放(并使用该内存块)…

现在我必须以不同的方式解决这个问题-而不是从Base继承，DynamicObject类包含unique_ptr和Base的对象作为成员变量-这样我可以控制构造/销毁的顺序，但也有一些负面的方面:

  • 我必须为Base中应该由派生类暴露的每个函数提供包装器
  • 我必须提供转换运算符(const)引用Base，因为我想通过引用基类
    • 使用对象

我考虑过使用多重继承，这样DynamicObject将从两个基础继承-一个将提供存储(私有继承)和Base(继承功能)-这样我也可以得到正确的构造/销毁顺序，但以使用"邪恶"多重继承为代价…

请注意，上面的例子只是一个简化。真正的用例是我正在编写的RTOS的线程和消息队列之类的对象(https://github.com/DISTORTEC/distortos) -请参阅Dynamic*.hpp和Static*.hpp对象以获取实际示例- https://github.com/DISTORTEC/distortos/tree/master/include/distortos

有什么聪明的技巧可以让我用某种方式颠倒毁灭的顺序吗?类似于上面DynamicObject的委托构造函数的使用?也许有更好的方法来达到同样的结果?

您需要使用类型擦除删除器，以与shared_ptr相同的方式(但与unique_ptr不同，它成为类型的一部分)。

class Base
{
public:
    typedef void (*StorageDeleter)(void*);
    Base(void* storage, size_t storageSize, StorageDeleter deleter = nullptr) :
        storage_{storage},
        storageSize_{storageSize},
        deleter_{deleter}
    {
        // do something with the storage...
    }
    virtual ~Base()
    {
        // do something with the storage...
        if (deleter_) deleter_(storage_);
    }
    // member functions
private:
    void* storage_;
    size_t storageSize_;
    StorageDeleter deleter_;
};
/* no changes to this one */
template<size_t Size>
class StaticObject;
class DynamicObject : public Base
{
    static void array_deleter(void* p) { uint8_t* pExact = (uint8_t*)p; delete [] pExact; }
public:
    DynamicObject(size_t size) :
        DynamicObject{std::unique_ptr<uint8_t[]>{new uint8_t[size]}, size}
    {
    }
private:
    DynamicObject(std::unique_ptr<uint8_t[]>&& dynamicStorage, size_t size) :
        Base{dynamicStorage.get(), size, &DynamicObject::array_deleter},
    {
        dynamicStorage.release();
    }
};

请注意，deleter是一个静态成员函数——它不需要DynamicObject的活动派生实例来正确操作。

我还修正了你对std::unique_ptr的使用，以便在Base构造期间抛出异常的情况下使用数组释放器(构造之后，deleter函数负责)。

现在，考虑(指针+delete)已经存在，以std::unique_ptr<T, Deleter>的形式存在。你可以输入:

class Base
{
    typedef void (*StorageDeleter)(void*);
    typedef std::unique_ptr<void, StorageDeleter> AutofreePtr;
public:
    Base(AutofreePtr&& storage, size_t storageSize) :
        storage_{std::move(storage)},
        storageSize_{storageSize}
    {
        // do something with the storage...
    }
    virtual ~Base()
    {
        // do something with the storage...
    }
    // member functions
private:
    AutofreePtr storage_;
    size_t storageSize_;
};
template<size_t Size>
class StaticObject : public Base
{
    static void no_delete(void*) {}
public:
    StaticObject() :
        Base{{&storage, &StaticObject::no_delete}, Size}
    {
    }
private:
    typename std::aligned_storage<Size>::type staticStorage_;
};
class DynamicObject : public Base
{
    static void array_deleter(void* p) { uint8_t* pExact = (uint8_t*)p; delete [] pExact; }
public:
    DynamicObject(size_t size) :
        DynamicObject{{new uint8_t[size], &DynamicObject::array_deleter}, size}
    {
    }
};

这避免了在完全初始化之前使用存储对象进行工作的问题。

class Base
{
public:
    Base(void* storage, size_t storageSize) :
        storage_{storage},
        storageSize_{storageSize}
    {
    }
    virtual ~Base()
    {
    }
private:
    void* storage_;
    size_t storageSize_;
};
class Worker
{
    Worker(Base* storage)
        : storage(storage)
    {
        // do something with the storage
    }
    ~Worker()
    {
        // do something with the storage
    }
    Base* storage;
};
Base* storage = new FancyStorage;
Worker w(storage);
delete storage;

我避免使用智能指针以保持简单，因为我不知道您希望如何拥有您的存储对象

听起来你真正想要的是颠倒层次结构;一个Base应该有一些存储空间，而不是一个StaticObject有一个Base。例如，可以用泛型

来实现。
template< typename Storage >
class Base
{
    Storage storage; // Storage could be a private base class too
public:
    // Fix: use perfect forwarding
    template< typename T... >
    Base(T ...args):Storage(args...) { /* More initialization */ }
    ~Base() {
        // Still safe to use storage!
    }
    void set_all_storate_to_zero()
    {
        memset(storage.ptr(), 0, storage.size());
    }
};
相关文章：