Основа

class variant_type
{
public:
    typedef void (*TFCopyConstructor)(void* /*dst*/, const void* /*src*/);
    typedef void (*TFDestructor)(void* obj);

    typedef std::vector<std::pair<ptrdiff_t, const variant_type*> > TSubPointers;

    const char*         m_Name;
    size_t              m_Size;
    size_t              m_AlignSize;
    TFCopyConstructor   m_CopyCnstr;
    TFDestructor        m_Destructor;

    bool                m_Initialized;
    TSubPointers        m_Pointers;

    template<class T>
    static variant_type* type_id()
    {
        static variant_type static_type( *(T const*)0 );
        return &static_type;
    }
private:
    ...
};

const variant_type* vt = variant_type::type_id<CMySuperClass>();
std::cout << vt->m_Name << " " << vt->m_Size;

CMySuperClass my_super_class;
byte* buf = new byte[vt->m_AlignSize];
vt->m_CopyCnstr( buf, &my_super_class );
CMySuperClass* object = reinterpret_cast<CMySuperClass*>( buf );
AnyUse( object );
vt->m_Destructor( buf );
delete[] buf;

class Foo
{
    P<int> i;
    int fake;
    P<CMySuperClass> m;
};

Общее описание пула памяти

- Для каждого конструктора объекта-указателя:
-   Если я пересекаюсь с верхним элементом стека конструкторов то:
-     Следовательно я мембер нового объекта и должен попытаються
отметиться в соответствующем variant_type если флажок m_Initialized == false
-   Иначе:
-     Я корневой указатель и должен добавиться в стек корневых указателей.
После конструирования объекта описание блока удаляется из стека.

Указатель

template<class T>
class P
{
public:
    P()             { Pool::Instance().ProcessPointer( (void**)this ); } 
    P(const P<T>& ) { Pool::Instance().ProcessPointer( (void**)this ); }
    ~P()            { Pool::Instance().FreePointer( (void**)this ); }

    template<class U>
    P(const P<U>& ) { Pool::Instance().ProcessPointer( (void**)this ); }

    T* operator->() { return p; }

   // функции сравнения, разыменования, работы с GC_NULL и т.п.
   ...

private:
    T* p;
};

gc_new

template<class T>
P<T> Pool::gc_new()
{
    // Получаем рантайм тип.
    variant_type* vt = variant_type::type_id<T>();
    // Получаем блок памяти для объекта
    // Очень дешёвая операция, просто увелчиваем счётчик размера выделенной памяти на (sizeof(TMemBlock) + sizeof(T))
    P<T> p; p.p = (T*)GetMemory( vt );
    // проверяем иницилизированность рантайм типа и если нет - начинаем инициализацию:
    if ( !vt->m_Initialized )
        vt->m_Pointers.resize( 0 );
    // добавляем в стек конструкторов информацию об обрабатываемом блоке памяти:
    m_builder.push_back( Pool::TAllocatingBlock( (byte*)p.p, vt) );
    // конструируем объект
    new (p.p) T;
    // все указатели-мемберы уже отмечены
    m_builder.pop_back();
    // и рантаймтип в любом случае уже инициализирован
    vt->m_Initialized = true;
    return p;
}

P<T> gc_new()
{
    return Pool::Instance().gc_new<T>();
}

Чистка памяти

void Pool::GC()
{
    //Рекурсивно, начиная с корневых указателей, обходим доступный граф и помечаем заголовки блоков как доступные.
    MarkUsedBlocks();

    // Выделяем новый кусок памяти.
    std::vector<uint8_t> window( m_buffer.size() );

    // Последовательно проходим по всем блокам.
    // Если они отмечены - копируем соответствующий объект с помощью variant_type::m_CopyCnstr
    // в новый блок, и в заголовок старого блока (вместо variant_type) происываем diffptr_t между новым и старым блоком.
    // Если блок не был отмечен - он удаляется с помощью функции: variant_type::m_Destructor
    MoveUsedBlocks( &window[0], m_allocated );

    // делаем актуальным новый блок
    window.swap( m_buffer );

    // Последовательно проходим по всем блокам и обновляем им указатели используя diffptr_t записанный в старой памяти
    UpdatePointersInNewBlocks( &m_buffer[0], &m_buffer[0] + m_allocated );

    // Проходим по всем корневым указателям и обновляем их тоже
    UpdateRootPointers();

Немного о проблемах