Thanks for your answers.
From what i learnt from the FAQ, if i want that only the objects
created through my new(size_t, const string&, int) call my overloaded
delete, i must redefine delete(void*, const string& , int ).
I rewrote my code with Singleton and correct symbols, but if i redefine
delete(void*, const string&, int), the program crash in dbgheap.c:1252
(_CrtIsValidHeapPointer). If i comment my 'new' delete an keep the old
delete(void*), i get the same output than in the first message.
Silver
----------------
// heap.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#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* Instance();
void* myNew (size_t size, const string& filename, int line);
void myDelete (void* addr);
private:
typedef map<void*, BlockDescriptor*> t_blocksMap;
t_blocksMap BlocksMap;
HeapManager();
HeapManager(const HeapManager&);
HeapManager& operator= (const HeapManager&);
~HeapManager ();
};
HeapManager::HeapManager()
{
}
HeapManager::HeapManager(const HeapManager&)
{
}
HeapManager& HeapManager::operator = (const HeapManager&)
{
return *Instance();
}
HeapManager* HeapManager::Instance()
{
static HeapManager inst;
return &inst;
}
HeapManager::~HeapManager ()
{
vector<t_blocksMap::iterator> toErase;
t_blocksMap::iterator i;
for(i=BlocksMap.begin(); i!=BlocksMap.end(); i++) {
cout << "leak : " << i->second->filename << ":" << i->second->line
<<endl;
free(i->second);
free(i->first);
toErase.push_back(i);
}
for(unsigned int j =0; j<toErase.size(); j++) {
BlocksMap.erase(toErase[j]);
}
}
void* HeapManager::myNew(size_t size, const string& filename, int line)
{
if(size <= 0)
return 0;
BlockDescriptor* pDesc =
(BlockDescriptor*)malloc(sizeof(BlockDescriptor));
pDesc->size = size;
strncpy(pDesc->filename,filename.data(),99);
pDesc->filename[99] = '\0';
pDesc->line = line;
void* block = malloc(size);
BlocksMap.insert(make_pair(block,pDesc));
cout << "registered : " << block << endl;
return block;
}
void HeapManager::myDelete(void* addr)
{
if(addr == 0)
return;
cout << addr << " ";
t_blocksMap::iterator i = BlocksMap.find(addr);
if (i != BlocksMap.end()) {
cout << "_Delete ok " << endl;
free(i->second);
BlocksMap.erase(i);
} else {
cout << "_Delete unregistered" << endl;
}
free(addr);
}
void* operator new(size_t size, const string& filename, int line) {
return HeapManager::Instance()->myNew(size, filename, line);
}
void* operator new[](size_t size, const string& filename, int line) {
return HeapManager::Instance()->myNew(size, filename, line);
}
void operator delete(void* addr, const string& filename, int line) {
HeapManager::Instance()->myDelete(addr);
}
void operator delete[](void* addr, const string& filename, int line){
HeapManager::Instance()->myDelete(addr);
}
/*
void operator delete (void* addr) {
HeapManager::Instance()->myDelete(addr);
}
void operator delete [] (void* addr) {
HeapManager::Instance()->myDelete(addr);
}*/
#define new new(__FILE__,__LINE__)
class Foo
{
public:
int bar;
};
int main()
{
Foo* ptr = new Foo;
Foo* ptr2 = new Foo;
delete ptr;
delete ptr2;
return 0;
}