我想在我的项目中进行内存管理。我不希望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 ...哦......
有什么方法可以解决这个问题吗？
如果 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);
}
您可以尝试覆盖基类的运算符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
在这种情况下，operator delete收到了正确的地址。