Question

我想在我的项目中进行内存管理。我不希望operator global new / delete所以我实现了一个简单的内存alloctor。这是我的代码：

class IAllocator
{
public:
    void* Alloc( unsigned int size )
    {
        1. alloc memory.
        2. trace alloc.
    }
    void Dealloc( void* ptr )
    {
        1. free memory.
        2. erase trace info.
    }
    template< typename T >
    void Destructor( T* ptr )
    {
        if ( ptr )
            ptr->~T();
    }
};
// macro for use easy.
# define MYNEW( T ) new ( g_Allocator->Alloc( sizeof( T ) ) ) T
# define MYDEL( ptr ) if (ptr) { g_Allocator->Destructor(ptr); g_Allocator->Dealloc(ptr); }

然后，我可以使用MYNEW来构造对象（还有用于检查内存泄漏的跟踪alloc信息），以及用于销毁对象的MYDEL（擦除跟踪信息）。

一切看起来很好......但是，当我尝试将此方法用于多继承类时，我发现了一个非常严重的问题。看下面的测试代码：

class A { ... };
class B { ... };
class C : public A, public B { ... };

C* pkC = MYNEW( C );
B* pkB = (B*)pkA;
MYDEL( pkB );

pkB和pkA的地址不相等。因此内存不会自由纠正，而且分配跟踪信息也不会擦除coorect ...哦......

有什么方法可以解决这个问题吗？

Answer 1

如果ptr指向多态类的实例，dynamic_cast<void*>(ptr)将导致指向ptr指向的派生对象最多的指针。换句话说，这个动态转换产生一个指向分配地址的指针。

但是，使用g_Allocator->Dealloc(dynamic_cast<void*>(ptr))不是一个可行的解决方案。问题是如果dynamic_cast<void*>(ptr)指向非类对象（例如，基元）或非多态类的实例，则ptr是非法的。

你可以做的是使用SFINAE来创建一个函数，该函数使用这个动态转换来指向多态类，但是使用静态转换来指向非类对象和非多态类的实例。 Boost（现在是C ++ 11）提供is_class<T>和is_polymorphic<T>类型特征，这将有助于此。

示例：

template <typename T, bool is_poly>
struct GetAllocatedPointerHelper {
   static void* cast (T* ptr) { return ptr; }
};

template <typename T>
struct GetAllocatedPointerHelper<T, true> {
   static void* cast (T* ptr) { return dynamic_cast<void*>(ptr); }
};

template<typename T>
inline void*
get_allocated_pointer (T* ptr)
{
   const bool is_poly = Boost::is_polymorphic<T>::value;
   return GetAllocatedPointerHelper<T, is_poly>::cast(ptr);
}

Answer 2

您可以尝试覆盖基类的运算符new和delete，并派生您希望自定义分配器来自该类的所有类。以下是一个简单的样本：

#include <cstdio>
#include <cstdlib>

class Base
{
    public:
        virtual ~Base(){};

        void* operator new(size_t size){return malloc(size);}
        void operator delete(void* pointer){printf("\n%x\n", pointer); free(pointer);}
};

class A : public virtual Base
{
    public:
        ~A(){printf("~A");};
};

class B : public virtual Base
{
    public:
        ~B(){printf("~B");};
};

class C : public A, public B
{
    public:
        ~C(){printf("~C");};
};

int main()
{
    C* c = new C();
    printf("%x\n", c);

    B* b = dynamic_cast<B*>(c);
    printf("%x\n", b);

    delete b;

    return 0;
}

一个可能的输出是：

5831d0 5831d4~C~B~A 5831d0

在这种情况下，操作员删除收到了正确的地址。

自定义内存alloc和dealloc多个继承类

2 个答案: