class HeapTracked {                  // mixin class; keeps track of
public:                              // ptrs returned from op. new

  class MissingAddress{};            // exception class; see below

  virtual ~HeapTracked() =  0 ;

  static void *operator new(size_t size);
  static void operator delete(void *ptr);

  bool isOnHeap() const;

private:
  typedef const void* RawAddress;
  static list<RawAddress> addresses;
};

// mandatory definition of static class member
list<RawAddress> HeapTracked::addresses;

// HeapTracked destructor is pure virtual to make the
// class abstract (see Item E14). The destructor must still
// be defined, however, so we provide this empty definition.
HeapTracked::~HeapTracked() {}



void * HeapTracked::operator new(size_t size)
{
  void *memPtr = ::operator new(size);  // get the memory

  addresses.push_front(memPtr);         // put its address at
                                        // the front of the list
  return memPtr;
}

void HeapTracked::operator delete(void *ptr)
{
  // get an "iterator" that identifies the list
  // entry containing ptr; see Item 35 for details
  list<RawAddress>::iterator it =
    find(addresses.begin(), addresses.end(), ptr);

  if (it != addresses.end()) {       // if an entry was found
    addresses.erase(it);             // remove the entry
    ::operator delete(ptr);          // deallocate the memory
  } else {                           // otherwise
    throw MissingAddress();          // ptr wasn't allocated by
  }                                  // op. new, so throw an
}                                    // exception

bool HeapTracked::isOnHeap() const
{
  // get a pointer to the beginning of the memory
  // occupied by *this; see below for details
  const void *rawAddress = dynamic_cast<const void*>(this);

  // look up the pointer in the list of addresses
  // returned by operator new
  list<RawAddress>::iterator it =
    find(addresses.begin(), addresses.end(), rawAddress);

  return it != addresses.end();      // return whether it was
}                                    // found

const void *rawAddress = dynamic_cast<const void*>(this);

#include <new>
#include <memory>
#include <iostream>
#include <iomanip>

class Base {
	int _val1;
public:
	static void* operator new(size_t size);
	static void operator delete(void *ptr, size_t size);
	virtual ~Base();
};

void* Base::operator new(size_t size) {
	void* retVal = ::operator new(size);
	std::cout<<std::dec<<size<<" bytes has been allocated. The return value is: 0x"
		<<std::hex<<reinterpret_cast<unsigned long>(retVal)<<"\n";
	return retVal;
}

void Base::operator delete(void *ptr, size_t size) {
	std::cout<<"Deallocating "<<std::dec<<size<<" bytes for the pointer referencing at 0x"
		<<std::hex<<reinterpret_cast<unsigned long>(ptr)<<"\n";
	::operator delete(ptr);
}

Base::~Base() { }

class Derived : public Base {
	int _val2;
public:
	virtual ~Derived();
};

Derived::~Derived() { }

int main(int argc, char **argv) {
	std::auto_ptr<Base> base(new Base);
	std::auto_ptr<Derived> derived(new Derived);
} 

 8  bytes has been allocated. The return value is: 0x321148
 12  bytes has been allocated. The return value is: 0x322640
Deallocating  12  bytes for the pointer referencing at 0x322640
Deallocating  8  bytes for the pointer referencing at 0x321148
Press any key to continue