I'm trying to create a basic Heap manager and i have some question
about new/delete overloading.
The following code give me this output :
$./heap
registered : 0x804d098
0x804d008 _Delete unknown block
registered : 0x804d138
0x804d008 _Delete unknown block
0x804d098 _Delete ok
0x804d0a8 _Delete unknown block
0x804d138 _Delete ok
0x804d148 _Delete unknown block
Why is the HeapManager::_D elete called to delete objects that weren't
created using HeapManager::_N ew ?
The only reason I see is that these calls come from my BlocksMap
internals. Is it possible to differenciate delete used by the libstdc++
and delete used by the parts of my programs which are after the
overloading ?
Thanks for any advice :-)
Silver
------------------------------------------------
#include <map>
#include <vector>
#include <stdlib.h>
#include <string>
#include <string.h>
#include <iostream>
using namespace std;
class HeapManager
{
public:
struct BlockDescriptor {
size_t size;
char filename[100];
int line;
};
static HeapManager* pSelf;
~HeapManager ();
void* _New (size_t size, const string& filename, int line);
void _Delete (void* addr);
private:
typedef map<void*, BlockDescriptor *> t_blocksMap;
t_blocksMap BlocksMap;
};
HeapManager::~H eapManager ()
{
vector<t_blocks Map::iterator> toErase;
t_blocksMap::it erator i;
for(i=BlocksMap .begin(); i!=BlocksMap.en d(); i++) {
cout << "leak : " << i->second->filename << ":" << i->second->line
<<endl;
free(i->second);
free(i->first);
toErase.push_ba ck(i);
}
for(unsigned int j =0; j<toErase.size( ); j++) {
BlocksMap.erase (toErase[j]);
}
}
void* HeapManager::_N ew(size_t size, const string& filename, int line)
{
if(size <= 0)
return 0;
BlockDescriptor * pDesc =
(BlockDescripto r*)malloc(sizeo f(BlockDescript or));
pDesc->size = size;
strncpy(pDesc->filename,filen ame.data(),99);
pDesc->filename[99] = '\0';
pDesc->line = line;
void* block = malloc(size);
BlocksMap.inser t(make_pair(blo ck,pDesc));
cout << "registered : " << block << endl;
return block;
}
void HeapManager::_D elete(void* addr)
{
if(addr == 0)
return;
cout << addr << " ";
t_blocksMap::it erator i = BlocksMap.find( addr);
if (i != BlocksMap.end() ) {
cout << "_Delete ok " << endl;
free(i->second);
BlocksMap.erase (i);
} else {
cout << "_Delete unknown block" << endl;
}
free(addr);
}
void* operator new(size_t size, const string& filename, int line) {
return HeapManager::pS elf->_New(size, filename, line);
}
void* operator new[](size_t size, const string& filename, int line) {
return HeapManager::pS elf->_New(size, filename, line);
}
void operator delete (void* addr) {
HeapManager::pS elf->_Delete(addr );
}
void operator delete [] (void* addr) {
HeapManager::pS elf->_Delete(addr );
}
#define new new(__FILE__,__ LINE__)
HeapManager* HeapManager::pS elf = NULL;
HeapManager theHeap;
class Foo
{
public:
int bar;
};
int main()
{
HeapManager::pS elf = &theHeap;
Foo* ptr = new Foo;
Foo* ptr2 = new Foo;
delete ptr;
delete ptr2;
return 0;
}
