具有虚拟析构函数的池分配器

Question

我正在使用旧的 C++03 代码库。一个部分看起来像这样：

#include <cstddef>

struct Pool
{ char buf[256]; };

struct A
{ virtual ~A() { } };

struct B : A
{
  static void *operator new(std::size_t s, Pool &p) { return &p.buf[0]; }
  static void operator delete(void *m, Pool &p) { } // Line D1
  static void operator delete(void *m) { delete m; } // Line D2
};

Pool p;

B *doit() { return new(p) B; }

也就是说，B 派生自 A，但 B 的实例是从内存池中分配的。

（注意这个例子有点过于简单了......实际上，池分配器做了一些不平凡的事情，因此需要在 D1 行放置 operator delete。）

最近，我们在更多编译器上启用了更多警告，第 D2 行引发以下警告：

警告：删除‘void*’未定义[-Wdelete-incomplete]

嗯，是的，很明显。但由于这些对象总是从池中分配的，我认为不需要自定义（非放置）operator delete。所以我尝试删除 D2 行。但这导致编译失败：

new.cc：在析构函数“virtual B::~B()”中：new.cc:9:8: error: no 适合“B”结构 B 的“运算符删除”：A ^ new.cc：在全局范围内：new.cc:18:31：注意：这里首先需要合成方法‘virtual B::~B()’ B *doit1() { return 新的（p）B； }

一点研究确定问题出在 B 的虚拟析构函数上。它需要调用非放置B::operator delete，因为某个地方的某个人可能会尝试通过A * 来delete 和B。由于名称隐藏，第 D1 行呈现默认的非放置 operator delete 不可访问。

我的问题是：处理此问题的最佳方法是什么？一个明显的解决方案：

static void operator delete(void *m) { std::terminate(); } // Line D2

但这感觉不对……我的意思是，我是谁坚持让你必须从池中分配这些东西？

另一个明显的解决方案（以及我目前使用的）：

static void operator delete(void *m) { ::operator delete(m); } // Line D2

但这也感觉不对，因为我怎么知道我调用了正确的删除函数？

我想，我真正想要的是using A::operator delete;，但这无法编译（“没有匹配‘A::operator delete’的成员在‘struct A’中”）。

相关但不同的问题：

Why is delete operator required for virtual destructors

Clang complains "cannot override a deleted function" while no function is deleted

[更新，扩大一点]

我忘了提到A 的析构函数在我们当前的应用程序中并不需要是virtual。但是从具有非虚拟析构函数的类派生会导致一些编译器在您提高警告级别时抱怨，而练习的最初目的是消除此类警告。

另外，为了明确期望的行为......正常的用例如下所示：

Pool p;
B *b = new (p) B;
...
b->~B();
// worry about the pool later

也就是说，就像大多数使用placement new 一样，您可以直接调用析构函数。或者调用一个辅助函数来为你做这件事。

我不会期望以下工作;事实上，我认为这是一个错误：

Pool p;
A *b_upcast = new (p) B;
delete b_upcast;

检测到这种错误使用并失败是可以的，但前提是它可以在不对非错误情况增加任何开销的情况下完成。 （我怀疑这是不可能的。）

最后，我确实希望这会起作用：

A *b_upcast = new B;
delete b_upcast;

换句话说，我想支持但不要求为这些对象使用池分配器。

我目前的解决方案大部分都有效，但我担心直接调用 ::operator delete 不一定是正确的。

如果您认为您有充分的理由证明我对应该或不应该起作用的期望是错误的，我也想听听。

Answer 1

有趣的问题。如果我理解正确，您要做的就是根据它是否通过池分配来选择正确的删除运算符。

您可以在池中分配的块的开头存储一些额外的信息。

由于不能在没有池的情况下分配 B，因此您只需使用有关池的一些额外信息将其转发到普通 delete(void*) 运算符中的放置删除器。

Operator new 会将该部分存储在分配块的开头。

更新： 感谢您的澄清。同样的技巧仍然适用于一些小的修改。更新了下面的代码。 如果那仍然不是您想要做的，那么请提供一些正面和负面的测试用例来定义什么应该起作用，什么不应该起作用。

struct Pool
{
    void* alloc(size_t s) {
        // do the magic... 
        // e.g. 
        //    return buf;
        return buf;
    }
    void dealloc(void* m) {
        // more magic ... 
    }
private:

    char buf[256];
};
struct PoolDescriptor {
    Pool* pool;
};


struct A
{
    virtual ~A() { }
};

struct B : A
{
    static void *operator new(std::size_t s){
        auto desc = static_cast<PoolDescriptor*>(::operator new(sizeof(PoolDescriptor) + s));
        desc->pool = nullptr;
        return desc + 1;
    }

    static void *operator new(std::size_t s, Pool &p){
        auto desc = static_cast<PoolDescriptor*>(p.alloc(sizeof(PoolDescriptor) + s));
        desc->pool = &p;
        return desc + 1;
    }
    static void operator delete(void *m, Pool &p) {
        auto desc = static_cast<PoolDescriptor*>(m) - 1;
        p.dealloc(desc);
    }
    static void operator delete(void *m) {
        auto desc = static_cast<PoolDescriptor*>(m) - 1;
        if (desc->pool != nullptr) {
            throw std::bad_alloc();
        }
        else {
            ::operator delete (desc);
        } // Line D2
    }
};


Pool p;
void shouldFail() { 
    A* a = new(p)B;
    delete a;
}
void shouldWork() { 
    A* a = new B;
    delete a;
}

int main()
{
    shouldWork();
    shouldFail();
    return 0;
}

Answer 2

真的很难理解你打算用这段代码实现什么，因为你剥离了它的重要部分。

你知道static void operator delete(void *m, Pool &p) { } 只有在 B 的构造函数抛出异常时才会被调用？

15) 如果已定义，则由自定义单对象放置调用 new 如果对象的构造函数具有匹配签名的表达式 抛出异常。如果定义了特定于类的版本 (25)，它 优先于 (9) 调用。如果既没有提供 (25) 也没有提供 (15) 由用户调用，不调用释放函数。

这意味着在当前的例子中这个操作符 delete (D1) 永远不会被调用。

在我看来，有一个带有虚析构函数的基类 A 看起来很奇怪，并且坚持认为删除调用的语义是不同的，这取决于对象的创建方式。

如果您确实需要基类 A，并添加虚拟析构函数只是为了使警告静音，您可以将析构函数设置在 A 中，而不是使其成为虚拟。像这样-

struct A
{
protected:
  ~A() { }
};

struct B final : public A
{
  ~B() = default;

  static void *operator new(std::size_t s, Pool &p) { return &p.buf[0]; }
  static void operator delete(void *m, Pool &p) {} // Line D1

  static void operator delete(void *m) {} // Line D2

};