简单的多重继承

struct A {};
struct B {};
struct C : A, B {};

或虚拟继承

struct B {};
struct C : virtual B {};

请注意类型不是多态的。

自定义内存分配:

template <typedef T, typename... Args>
T* custom_new(Args&& args...)
{
    void* ptr = custom_malloc(sizeof(T));
    return new(ptr) T(std::forward<Args>(args)...);
}

template <typedef T>
void custom_delete(T* obj)
{
    if (!obj)
        return obj;

    void* ptr = get_allocated_ptr(obj); // here
    assert(std::is_polymorphic_v<T> || ptr == obj);
    obj->~T();
    custom_free(ptr); // heap corruption if assert ^^ failed
}

B* b = custom_new<C>(); // b != address of allocated memory
custom_delete(b); // UB

我如何实现 get_allocated_ptr对于非多态类型？对于多态类型 dynamic_cast<void*>完成工作。

或者我可以检查 obj是指向基类的指针，因为通过指向基类的指针删除非多态对象是 UB。我不知道该怎么做，也不知道是否可行。

operator delete在这种情况下正确地释放内存(例如 VC++)，尽管标准说它是 UB。它是怎么做到的？特定于编译器的功能？

最佳答案

您实际上遇到了比获取完整对象的地址更严重的问题。考虑这个例子:

struct Base
{
  std::string a;
};

struct Derived : Base
{
  std::string b;
};

Base* p = custom_new<Derived>();
custom_delete(p);

在这个例子中，custom_delete 实际上会释放正确的地址(static_cast<void*>(static_cast<Derived*>(p)) == static_cast<void*>(p))，但是行obj->~T()将为 Base 调用析构函数，意思是 b字段泄露。

所以不要那样做

而不是从 custom_new 返回原始指针，返回一个绑定(bind)到类型 T 并且知道如何删除它的对象。例如:

template <class T> struct CustomDeleter
{
  void operator()(T* object) const
  {
    object->~T();
    custom_free(object); 
  }
};

template <typename T> using CustomPtr = std::unique_ptr<T, CustomDeleter<T>>;

template <typename T, typename... Args> CustomPtr<T> custom_new(Args&&... args)
{
  void* ptr = custom_malloc(sizeof(T));
  try
  {
    return CustomPtr<T>{ new(ptr) T(std::forward<Args>(args)...) };
  }
  catch (...)
  {
    custom_free(ptr);
    throw;
  }
}

现在不可能意外释放错误的地址并调用错误的析构函数，因为调用 custom_free 的唯一代码知道它要删除的东西的完整类型。

注意:注意 unique_ptr::reset(pointer) 方法。使用自定义删除器时，此方法非常危险，因为调用者有责任提供以正确方式分配的指针。如果使用无效指针调用该方法，编译器将无能为力。

传递基指针

您可能希望将基指针传递给函数并让该函数负责释放对象。在这种情况下，您需要使用类型删除 向消费者隐藏对象的类型，同时在内部保留其最派生类型的知识。最简单的方法是使用 std::shared_ptr .例如:

struct Base
{
  int a;
};

struct Derived : Base
{
  int b;
};

CustomPtr<Derived> unique_derived = custom_new<Derived>();

std::shared_ptr<Base> shared_base = std::shared_ptr<Derived>{ std::move(unique_derived) };

现在可以自由绕过shared_base当最终引用发布时，完整的 Derived对象将被销毁并将其正确地址传递给 custom_free .如果你不喜欢 shared_ptr 的语义, 用 unique_ptr 创建类型删除指针相当简单语义。

注意:此方法的一个缺点是 shared_ptr 需要为其控制 block 单独分配(不会使用 custom_malloc )。通过多做一些工作，您可以解决这个问题。您需要创建一个包装 custom_malloc 的自定义分配器和 custom_free然后使用 std::allocate_shared创建您的对象。

完整的工作示例

#include <memory>
#include <iostream>

void* custom_malloc(size_t size)
{
  void* mem = ::operator new(size);
  std::cout << "allocated object at " << mem << std::endl;
  return mem;
}

void custom_free(void* mem)
{
  std::cout << "freeing memory at " << mem << std::endl;
  ::operator delete(mem);
}

template <class T> struct CustomDeleter
{
  void operator()(T* object) const
  {
    object->~T();
    custom_free(object); 
  }
};

template <typename T> using CustomPtr = std::unique_ptr<T, CustomDeleter<T>>;

template <typename T, typename... Args> CustomPtr<T> custom_new(Args&&... args)
{
  void* ptr = custom_malloc(sizeof(T));
  try
  {      
    return CustomPtr<T>{ new(ptr) T(std::forward<Args>(args)...) };
  }
  catch (...)
  {
    custom_free(ptr);
    throw;
  }
}

struct Base
{
  int a;
  ~Base()
  {
    std::cout << "destroying Base" << std::endl;
  }
};

struct Derived : Base
{
  int b;
  ~Derived()
  {
    std::cout << "detroying Derived" << std::endl;
  }
};

int main()
{
  // Since custom_new has returned a unique_ptr with a deleter bound to the
  // type Derived, we cannot accidentally free the wrong thing.
  CustomPtr<Derived> unique_derived = custom_new<Derived>();

  // If we want to get a pointer to the base class while retaining the ability
  // to correctly delete the object, we can use type erasure.  std::shared_ptr
  // will do the trick, but it's easy enough to write a similar class without
  // the sharing semantics.
  std::shared_ptr<Base> shared_base = std::shared_ptr<Derived>{ std::move(unique_derived) };

  // Notice that when we release the shared_base pointer, we destroy the complete
  // object.
  shared_base.reset();
}

关于c++ - 通过指向非多态类型的基类的指针获取已分配内存的地址，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43225753/