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

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

正如您在委托(delegate)构造函数中看到的那样，我设法在将存储用于 Base 的构造函数之前创建(分配)存储。 - 稍微“颠倒”施工顺序。这个特定阶段也可以正常工作。问题是析构函数，因为我真的想不出任何解决我的问题的方法——在上面的代码中，动态分配的存储将在 Base 的析构函数之前被释放。开始运行(并使用这个内存块)...

现在我不得不以不同的方式解决这个问题——而不是继承自 Base , DynamicObject类包含 unique_ptr和 Base 的对象作为成员变量——这样我可以控制构造/破坏的顺序，但也有一些消极的一面:

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

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

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

有什么巧妙的技巧可以用来颠倒破坏顺序吗？类似于 DynamicObject 的委托(delegate)构造函数的使用多于？也许有更好的方法来达到相同的结果？

最佳答案

您需要使用类型删除的删除器，其方式与 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 期间抛出异常时使用数组释放器(构造完成后，删除函数负责)。

现在，考虑 (pointer+deleter) 已经存在，形式为 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}
    {

    }
};

关于c++ - 是否可以颠倒破坏顺序？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33224013/