新/删除运算符重载和基类

Question

我现在很头疼。

基本上我有这个：

Class A -> Class B
Class A -> Class C
Class A -> Class D

Class E with constructor with declaration E(int, A *objptr, bool IsObjPtrOwner = true)

如您所见，B C 和 D 继承自 A，A 是基类。 D 类必须具有特定的对齐方式（因为在其中使用了 SSE2），因此我在其中重载了 new/delete，每次动态分配对象时都提供对齐的内存块。我还应该提到，因为 A B C 和 D 不同，我几乎猜 B C A 和 D 的大小根本不一样。

所以我希望能够做到这一点：

E eobj(12, new D(2.001), true);

因为参数 IsObjPtrOwner 为真，所以我对 E 类进行了编程，如果成员 m_IsObjPtrOwner 为真，则在 E 的析构函数中删除指针 m_objptr。

这对我来说非常方便，可以在构造对象 E 的同时直接动态分配 A 的派生类之一，而不必在以后关心它。这样做的原因是我将在整个程序中创建很多 E 类实例，每次都使用不同的 B/C/D 实例。所以我不想在每次构造 E 的实例时保留我创建的每个指针的副本。

所以我尝试让 new/delete 操作符成为纯虚拟的，但它不起作用。该死的函数必须是静态的，非常烦人。所以我试图尽可能地规避这个问题，但我最终发现我不能在静态函数中使用“this”。

我能做什么？我怎样才能实现这个梦想？我有一个梦想……

---

编辑：由于某些原因，人们根本不明白我想说什么。

我有一个基类 A 和一组从 A 派生的类 B/C/D。我有一个类 E，在其构造函数中将一个类 A 的指针作为参数，然后将其存储在一个成员中，比如说m_bcdobj，所以我有这个：

class B : public A {
    B(double x) : m_x(x) { bla bla bla}
    void *operator new(size_t size)   { return Util_MemAlign(size, 4); }
    void  operator delete(void* ptr)  { Util_AlignFree(ptr); }
}
class C : public A {
    C(double x) : m_x(x) { bla bla bla}
    void *operator new(size_t size)   { return malloc(size); }
    void  operator delete(void* ptr)  { free(ptr); }
}
class D : public A {
    D(double x) : m_x(x) { bla bla bla}
    void *operator new(size_t size)   { return Util_MemAlign(size, 16); }
    void  operator delete(void* ptr)  { Util_AlignFree(ptr); }
}

如您所见，每个人都有不同的对齐要求。

现在我有一个 E 类：

class E {
    public:
        E(int z, A *bcdobj, bool IsObjPtrOwner = true) : m_z(z), m_bcdobj(bcdobj), m_freebcd(IsObjPtrOwner) { bla bla bla }

        ~E() { if (m_freebcd) { delete m_bcdobj; } }

    private:
        A *m_bcdobj;
        int m_z;
        bool m_freebcd;
}

所以我希望能够做到这一点：

E einst(2, new D(2.001));

即我不保留分配的 D 对象的副本。当“einst”被销毁时，分配的 D 对象将被释放。问题是这段代码不起作用。删除~E()中的m_bcdobj时，不会调用D中重载的删除操作符。

谢谢！

Answer 1

operator delete 的特殊之处在于尽管是静态成员，但如果该类具有虚拟析构函数，则它会被动态调度。 §12.5 [class.free]/p4：

如果删除表达式用于释放一个类对象，其 静态类型有一个虚析构函数，释放函数是 在动态类型的虚拟定义点选择一个 析构函数 (12.4)。

例如，

struct B {
    virtual ~B() = default;
    void operator delete(void* ptr) { 
        std::cout << "B's operator delete" << std::endl; ::operator delete(ptr); 
    }
};
struct D : B {
    void operator delete(void* ptr) { 
        std::cout << "D's operator delete" << std::endl; ::operator delete(ptr); 
    }
};
int main() {
    B* bp = new D;
    delete bp; //1: uses D::operator delete(void*)
}

prints:

D's operator delete

因此，给A 一个虚拟析构函数，您应该会看到正确的operator delete 调用:)。