Ich möchte Speicherverwaltung in meinem Projekt tun. Ich möchte nicht, dass der Operator global neu / löschen ist, also implementiere ich einen einfachen Speicher-Alloctor. Das ist mein Code:

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); }

Dann kann ich MYNEW verwenden, um ein Objekt zu konstruieren (auch Trace-Zuweisungsinformationen für das Überprüfen des Speicherverlusts) und MYDEL, um ein Objekt zu zerstören (Trace-Informationen löschen).

Alles sieht gut aus ... aber wenn ich versuche, diese Methode für mehrere Vererbungsklassen zu verwenden, stieß ich auf ein sehr ernstes Problem. Schau dir meinen Testcode unten an:

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

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

Die Adresse von pkB und pkA ist nicht gleich. so wird der Speicher nicht frei richtig, und die Allocation-Trace-Informationen werden auch nicht gelöscht coorect ... oh ...

Gibt es eine Möglichkeit, dieses Problem zu lösen?