Estoy tratando de hacer un Memory Manager basandome en la info que te explican en el libro "C++ for Game Programmers". El problema es que no tengo el cd con las soluciones propuestas, y no se solucionar un error.
Posteo primero el código y ahora comento:
Heap.h
- Código: Seleccionar todo
#ifndef Heap_H
#define Heap_H
#include <string>
#include <stdlib>
class Heap
{
public:
Heap(){};
Heap(const std::string& name):
mName(name),
mAllocs(0),
mAllocMem(0){};
~Heap(){};
void addAllocation(size_t size){ mAllocs++; mAllocMem += size; };
void remAllocation(size_t size){ mAllocs--; mAllocMem -= size; };
void* operator new(size_t size)
{
return malloc(size);
};
void operator delete(void* pMem)
{
free(pMem);
};
private:
std::string mName;
int mAllocs;
long int mAllocMem;
};
struct AllocHeader
{
int nSize;
unsigned int nSignature;
Heap* pHeap;
};
#endif
HeapFactory.h
- Código: Seleccionar todo
#ifndef HEAPFACTORY_H_INCLUDED
#define HEAPFACTORY_H_INCLUDED
#include "Heap.h"
#include <assert>
class HeapFactory
{
public:
HeapFactory(){};
~HeapFactory() {};
static Heap* getDefaultHeap() {return mDefaultHeap; };
static Heap* mDefaultHeap;
};
Heap* HeapFactory::mDefaultHeap = new Heap("Default");
void* operator new(size_t size, Heap* pHeap)
{
int nRequested_bytes = size + sizeof(AllocHeader) + sizeof(int);
char* pMem = (char*)malloc(nRequested_bytes);
AllocHeader* pHeader = (AllocHeader*)pMem;
pHeader->pHeap = pHeap;
pHeader->nSize = size;
pHeader->nSignature = 0xDEADC0DE;
pHeap->addAllocation(size);
void* pStart_memblock = pMem + sizeof(AllocHeader);
int* pEnd_block = (int*)pStart_memblock + size;
*pEnd_block = 0x1578E34D;
return pStart_memblock;
};
void* operator new(size_t size)
{
return ::operator new(size, HeapFactory::getDefaultHeap());
};
void operator delete(void* pMem)
{
AllocHeader* pHeader = (AllocHeader*)pMem - sizeof(AllocHeader);
assert(pHeader->nSignature == 0xDEADC0DE);
int* pEnd_memBlock = (int*)pMem + pHeader->nSize;
assert(*pEnd_memBlock == 0x1578E34D);
pHeader->pHeap->remAllocation(pHeader->nSize);
free (pHeader);
};
#endif // HEAPFACTORY_H_INCLUDED
El problema es el siguiente:
Yo quiero crear "Heaps" dinamicamente, pero el problema es que para el nuevo new necesito un Heap.
Mi solución, ha sido sobrecargar el operador new y delete de la clase Heap, para de esa manera llamar directamente a malloc y free y no tener ningún problema con los new y delete globales.
Pero cuando testeo mi código, resulta que a pesar de tener sobrecargados los operadores en la clase, me llama a los globales.
Alguien sabe a que se debe. ¿No pueden convivir ambos operadores sobrecargados? ¿Me falta algún punto?
Gracias a todos
