我的C++实践(15)：判断对象是在堆上还是在栈上

    1、要求对象分配在堆上： 栈上对象在定义时自动构造，在生存期结束时自动析构。因此可把析构函数声明为私有，这样栈上对象离开作用域时就会出错，不能自动析构。同时为了在堆上能够正确的创建和删除对象，提供一个伪析构函数来访问真正的析构函数。客户端使用时需要调用伪析构函数来销毁堆上的对象。
    例如，对于一个表示无限精度数字的类，要让对象只能创建在堆上，如下：

//upnumber1.hpp：表示无限精度数字的类，其对象只能创建在堆上 #ifndef UPNUMBER_HPP #define UPNUMBER_HPP class UPNumber{ public: UPNumber(){ //... } UPNumber(int val){ //... } UPNumber(double val){ //... } UPNumber(UPNumber const& rhs){ //... } void destroy() const{ //伪析构函数 delete this; } //... private: ~UPNumber(); //析构函数私有 }; #endif

//upnumber1test.cpp：对UPNumber，测试对象是否只能创建在堆上 #include "upnumber1.hpp" int main(){ UPNumber *p=new UPNumber; p->destroy(); //调用伪析构函数，不用直接用delete p; UPNumber n; //会报错，析构函数为私有，编译器不能创建栈对象（否则不能销毁） return 0; }

    注意，析构函数声明为私有的类不能被继承，也不能被其他类包含。我们可以放宽一点，把析构函数声明为protected的，这样就可以被继承，包含这个类的其他类可以通过包含这个类对象的指针，而不是对象来达到组合的目的。
    2、判断对象是否在堆上： 堆上的对象肯定通过new调用了operator new，而栈上的对象则没有调用它。因此可以给类增加一个标志变量flag来判断是否调用了operator new，类需要重写operator new来设置这个flag。同时增加一个公有的布尔变量onTheHeap以让客户端判断对象是否在堆上。在所有的构造函数中都需要根据flag是否被设置来初始化onTheHeap的值。
    对上面的UPNumber类，可做如下的设计：

//upnumber2.hpp：表示无限精度数字的类，可判断单个的对象或整个数组内存是否在堆上 #ifndef UPNUMBER_HPP #define UPNUMBER_HPP #include <cstddef> #include <new> class UPNumber{ private: static bool flag; void initHeapFlag(){ if(!flag){ //如果没有调用operator new和operator new[] onTheHeap=false; //说明是栈对象 }else{ onTheHeap=true; //否则调用了operator new或operator new[]，是堆对象 flag=false; //重置标志位 } } public: bool onTheHeap; static void* operator new(std::size_t size); static void* operator new[](std::size_t size) throw(std::bad_alloc); UPNumber(){ initHeapFlag(); //初始化onTheHeap标志 //... } UPNumber(int val){ initHeapFlag(); //... } UPNumber(double val){ initHeapFlag(); //... } UPNumber(UPNumber const& rhs){ initHeapFlag(); //... } //... }; bool UPNumber::flag=false; //静态变量在类外仍然需要定义 void* UPNumber::operator new(std::size_t size){ flag=true; //设计标志位为true return ::operator new(size); } void* UPNumber::operator new[](std::size_t size) throw(std::bad_alloc){ flag=true; return ::operator new[](size); } #endif

//upnumber2test.cpp：对UPNumber的测试，判断对象是否在堆上 #include "upnumber2.hpp" #include <iostream> int main(){ UPNumber a; //在栈上 std::cout<<a.onTheHeap<<std::endl; UPNumber *b=new UPNumber(); //在堆上 std::cout<<b->onTheHeap<<std::endl; delete b; UPNumber *num=new UPNumber[10]; //在堆上 std::cout<<num->onTheHeap<<std::endl; //相当于输出数组第1个元素是否在堆上 std::cout<<"The UPNumber array's heap flag: "<<std::endl; for(int i=0;i<10;++i){ //只有第1个对象会输出1表示在堆上，其余都会输出0，但实际上 //它们是在堆上的 std::cout<<num[i].onTheHeap<<std::endl; } return 0; }

    解释：
    （1）这样的设计只能判断单个的对象是否在堆上。我们还重写了operator new[]，这使得它可以判断整个数组所占的内存是否在堆上，但它却不能判断数组中的每个对象是否在堆上。从测试代码的运行结果就可以看出，对堆上的数组中的每个对象，只有第1个输出为1（即true），其余全部输出为0（即false），但我们知道实际上各个对象都在堆上的。这是因为创建整个数组时，operator new[]只会被调用一次，然后调用10次构造函数来初始化数组中的各个对象。当第1次调用构造函数时，onTheHeap被设为true，然后flag重置为false。后面的构造函数调用由于不会再调用operator new[]了，所以都会把onTheHeap设为false。
    （2）事实上，如果要实现在任何情况下都能判断对象是否在堆上，在C++中很难存在一种完全可移植的方案。比如，很多系统上，程序的地址空间都是按线性的顺序排列，栈从地址空间的高端往下增长，堆则从低端往上增长。这就可能通过把对象的地址（通过取址运算符&获得）与栈上的一个变量地址进行比较，若比栈变量地址小，则说明对象肯定在堆上。但并不是所有的系统都这样组织内存，而且很多系统的程序静态存储区会放在堆以下的地址空间中，这样就无法判断静态的栈对象了。这就是一种不可移植的方案，它依赖于系统的底层实现。一般UPNumber类中的实现基本能满足我们要求。因为只要通过第1个对象判断出了整个数组块是分配在堆上的，就自然知道了数组中的每个对象都是在堆上的（虽然它们的判断输出结果有出入）。
    （3）按照设计惯例，重写operator new和operator new[]，也要重写operator delete和operator delete[]，以保持对称。但这里我们只是设置了一下标志，并没有做其他定制性的工作，因此不对称也没关系。另一方面，要注意类的这些成员new和delete函数默认为static的，因为它们在构造对象之前或撤销对象之后运行，没有非静态的成员数据可操纵。
    我们可以把堆判断的功能抽离出来，设计成一个基类。为了使设计更完善，我们直接用一个列表来保存堆上的对象的地址，在重写的operator new中把分配的对象堆内存指针压入列表中。在重写的opeator delete中只要搜索这个列表，看看列表中有没有它的内存指针，有就说明是一个堆对象，需要释放内存，没有就说明是一个栈对象。

//heaptracked.hpp：HeapTracked类可判断单个的对象是否的在堆上 #ifndef HEAP_TRACKED_HPP #define HEAP_TRACKED_HPP #include <cstddef> #include <list> class HeapTracked{ private: static std::list<const void*> addresses; //存放各个堆对象的指针 public: class MissingAddress{ }; //异常类 virtual ~HeapTracked()=0; //纯虚函数 static void* operator new(std::size_t size); static void operator delete(void *ptr); bool isOnHeap() const; }; std::list<const void*> HeapTracked::addresses; //静态对象在类外仍需定义 HeapTracked::~HeapTracked(){ //纯虚的析构函数必须要有再定义 } void* HeapTracked::operator new(std::size_t size){ void *memPtr=::operator new(size); //分配内存 addresses.push_front(memPtr); //把地址压入列表前端 return memPtr; } void HeapTracked::operator delete(void *ptr){ if(ptr==0) return; //在列表中查找是否有这个指针 std::list<const void*>::iterator it= find(addresses.begin(),addresses.end(),ptr); if(it!=addresses.end()){ //若找到，说明指针指向了堆上的内存 addresses.erase(it); //从列表中移除这个指针 ::operator delete(ptr); //释放指针指向的内存 }else{ //否则ptr不是一个堆对象的指针，不能调用operator delete，抛出异常 throw MissingAddress(); } } bool HeapTracked::isOnHeap() const{ //获取*this对象的真正内存起始地址 const void* rawAddress=dynamic_cast<const void*>(this); //在列表中查找this指针 std::list<const void*>::iterator it= find(addresses.begin(),addresses.end(),rawAddress); return it!=addresses.end(); } #endif

//heaptrackedtest.cpp：对堆跟踪器HeapTracked类的测试 #include <iostream> #include "heaptracked.hpp" class Asset : public HeapTracked{ private: int value; public: //... }; int main(){ Asset a; std::cout<<a.isOnHeap()<<std::endl; //不在堆上 Asset *b=new Asset; std::cout<<b->isOnHeap()<<std::endl; //在堆上 delete b; return 0; }

    HeapTracked是抽象混合基类，因为它有纯虚函数，因此是抽象基类，不能被实例化，只能被继承，由子类来创建对象。它的很多非虚的成员函数有功能实现，因此又是一般的基类，这些功能代表了各个子类的共性，因此把它称为抽象混合基类。注意当把析构函数声明为纯虚的时，必须同时要有定义，因为子类一定会调用基类的析构函数，这样它就必须有定义，而不只是声明。在使用时，让需要堆判断功能的类直接继承HeapTracked类即可。注意这个类只能判断单个对象是否在堆上，不能判断数组是否在堆上，当然可以通过重写operator new[]来完善。唯一需要解释的就是那个dynamic_cast，它把this指针转换成const void*。因为由多继承或虚基类继承而来的对象会有多个地址，因此我们必须要把一个指针dynamic_cast成void*类型，这就会使它指向对象的真正内存开始处。
    3、禁止对象分配在堆上： 这个比较容易。把operator new/operator delete、operator new[]/operator delete[]都声明为私有即可。注意这样的类不能作为基类，也不能被其他类包含。