item26判断对象是否在堆中

#include <iostream>

using namespace std;
/*判断某个对象是否在heap*/
class A{
public:
A() ;
class NoOnHeap;
A(int ) { }
static void* operator new(size_t size);
void destroy() { delete this;}
protected:	//for B
static bool isOnHeap;
~A() { }//defined must be
};
bool isOnHeap = false;
A::A()
{
if(!isOnHeap)

throw NoOnHeap();
else
A(int);//一个正常的ctor，new不是正常的
isOnHeap = false;
}

void* operator new(size_t size)
{
isOnHeap = true;
return ::operator new(size);
}

/*不行的原因：判断位在有些情况下不能预期工作
1 operator new[]，new是分配一块内存，ctor来赋值
所以就算你有记得把判断位重置也没用，因为它就用一次new
2 A* pa = new(*new A) 理想状态下是 new - ctor - new - ctor
但实际上是 new new ctor ctor
*/

bool onHeap(const void* address)
{
char onStack;
return address < &onStack;
}
/*安妮他们在函数作用域中出现的次序来分配他们在栈中位置、但考虑static
一切就不对了，当想尽办法去加上if static的方法时，又要考虑不可移植，这时候
就要重新考虑是不是判断是否在堆中就是一个错误的思想，书上说，一般上client
都是想delete安全指针。但值得注意的是，delete this声名狼藉*/

/*且是否安全得delete 指针 与 是否在堆上并没有关系*/

void main()
{
C* c = new C;
delete c;
//哦哦，他把 A* vaule ==> A vaule 这样就是为了让它没有析构函数调用
}

class HeapTracked//足迹
{
public:
HeapTracked();
class missAddress;//用以抛出
virtual ~HeapTracked() = 0;
static void* operator new (size_t size);
static void operator delete (void *ptr);
bool isOnHeap();
private:
typedef const void* rawMemory;
list<rawMemory> addresses;
};

void * HeapTracked::operator new (size_t size)
{
void* address = ::operator new(size);
addresses.push_front();//头部？
return address;address
}

void HeapTracked::operator delete(void *ptr)
{
list<rawMemory>::const_iterator it =
find(addresses.begin(), addresses.end(), ptr);
if(it != addresses.end())
{	addresses.erase(it);
::operator delete ptr;
}
else
{
throw missAddress();
}
}

bool HeapTracked::isOnHeap()
{
const void * rawAddress = dynamic_cast<const void*>(this);
//取得一个指针，指向 *this 所占内存的起始处，我想不到的一部

list<rawMemory>::iterator it =
find(addresses.begin(), addresses.end(), rawAddress);

return it != addresses.end();
}