是否有可能颠倒破坏的顺序？

Question

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

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的委托构造函数？ 也许有更好的方法来实现相同的结果？

Answer 1

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

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;

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

Answer 2

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

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

Answer 3

您需要使用类型擦除的删除器，方式与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();
    }
};

请注意，删除器是一个静态成员函数-它并不需要的现场派生实例DynamicObject正常运行。

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

现在，考虑到（指针+删除）已经存在，以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}
    {

    }
};