C++放置new、继承和析构函数

Question

同学们，

在类层次结构上使用placement-new 时，基类必须进行解除分配。否则，基类析构函数将在一个解除分配的对象上被调用。 我希望能够从派生类执行取消分配。所以我愿意接受想法和建议！ （注意：我没有与placement-new 结婚，但我想要自定义内存管理而不是new/delete）。

请在下面找到一段示例代码：

#include <cstdint>
#include <cstdio>
#include <new>

class CParent
{
public :
    CParent() {
        printf("CParent()\n");
    }

    virtual ~CParent() {
        printf("~CParent()\n");
    }
};

class CAllocator
{
private :
    void Free(uint8_t *buffer) {
        printf("CAllocator::Free(%p)\n", buffer);
        delete [] buffer;
    }

    class CChild : public CParent
    {
    public :
        CChild(CAllocator &allocator, uint8_t *buffer)
            : mAllocator(allocator), mBuffer(buffer)
        {
            printf("CChild()\n");
        }

        ~CChild() {
            printf("~CChild()\n");
            mAllocator.Free(mBuffer);
        }

    private :
        CAllocator &mAllocator;
        uint8_t *mBuffer;
    };

public :
    CParent *Alloc() {
        uint8_t *buffer = new uint8_t[sizeof(CChild)];
        printf("CAllocator::Alloc() = %p\n", buffer);
        return new (buffer) CChild(*this, buffer);
    }
};

int main()
{
    CAllocator allocator;
    CParent *object = allocator.Alloc();

    // NB: Can't do `delete object` here because of placement-new
    object->~CParent();
    return 0;
}

它给出以下输出：

CAllocator::Alloc() = 0x2001010
CParent()
CChild()
~CChild()
CAllocator::Free(0x2001010)
~CParent()

所以~CParent()在内存被释放后被调用... 非常感谢您的帮助！

Answer 1

您以这样的方式混合以下概念，这让我认为您不清楚它们应该是什么：

1. 基类/派生类析构函数。
2. 放置new操作员。
3. 内存分配和释放。

当您使用普通的旧 operator new 分配对象时，会发生两件事：

1. 为对象分配内存。
2. 对象的构造函数（对于具有构造函数的类）被调用。

当您在 operator new 返回的指针上调用 operator delete 时，会发生两件事：

1. 对象的析构函数被调用。
2. 内存被释放。

当您使用展示位置new 运算符时，您必须：

1. 在调用 new 运算符之前分配内存。
2. 在调用new 时使用预先分配的内存。调用类的构造函数来初始化对象。

对于此类对象，您必须：

1. 显式调用析构函数。
2. 使用与内存分配方式相匹配的方法释放内存。如果您使用operator new char[size]; 分配内存，请使用delete [] ptr; 释放内存。如果您使用malloc(size) 分配内存，请使用free(ptr) 释放内存。

为了保持你的代码干净，你应该分开：

1. 负责分配和释放内存。
2. 调用构造函数和析构函数的职责。

在您发布的代码中，CChild 类似乎不干净。目前尚不清楚它是作为面向用户的类还是帮助您管理内存的帮助类。

如果你的意思是它是一个面向用户的类，我会将代码重构为：

#include <cstdint>
#include <cstdio>
#include <new>

class CParent
{
   public :
      CParent() {
         printf("CParent()\n");
      }

      virtual ~CParent() {
         printf("~CParent()\n");
      }
};

class CChild : public CParent
{
   public :
      CChild()
      {
         printf("CChild()\n");
      }

      ~CChild() {
         printf("~CChild()\n");
      }

   private :
};

class CAllocator
{
   public :
      void Free(uint8_t *buffer) {
         printf("CAllocator::Free(%p)\n", buffer);
         delete [] buffer;
      }


      uint8_t *Alloc(size_t size) {
         uint8_t *buffer = new uint8_t[size];
         printf("CAllocator::Alloc() = %p\n", buffer);
         return buffer;
      }
};

int main()
{
   CAllocator allocator;
   uint8_t *buffer = allocator.Alloc(sizeof(CChild));

   CParent* object = new (buffer) CChild;

   object->~CParent();

   allocator.Free(buffer);

   return 0;
}

如果您的意思是将CChild 用作管理内存的辅助类，那么您要做的第一件事就是确保CAllocator::Alloc() 和CAlloctor::Free() 是对称的。由于Alloc() 返回指向CParent 的指针，因此您需要更改Free() 以接受指向CParent 的指针并用它做正确的事情。我认为代码应该是这样的：

#include <cstdint>
#include <cstdio>
#include <new>

class CParent
{
   public :
      CParent() {
         printf("CParent()\n");
      }

      virtual ~CParent() {
         printf("~CParent()\n");
      }
};

class CAllocator
{
   private :

      class CChild : public CParent
      {
         public :
            CChild(uint8_t *buffer) : mBuffer(buffer)
            {
               printf("CChild()\n");
            }

            ~CChild() {
               printf("~CChild()\n");

               // The object has ownership of the buffer.
               // It can deallocate it.
               delete [] mBuffer;
            }

         private :
            uint8_t *mBuffer;
      };

   public :

      // Make Alloc and Free symmetric.
      // If Alloc() returns a CParent*, make sure Free()
      // accepts the same value and does the right thing
      // with it.

      CParent *Alloc() {
         uint8_t *buffer = new uint8_t[sizeof(CChild)];
         printf("CAllocator::Alloc() = %p\n", buffer);

         // Transfer the ownership of buffer to CChild
         return new (buffer) CChild(buffer);
      }

      void Free(CParent* object) {
         printf("CAllocator::Free(%p)\n", object);
         object->~CParent();
      }


};

int main()
{
   CAllocator allocator;

   CParent *object = allocator.Alloc();
   allocator.Free(object);

   return 0;
}