我的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[]都声明为私有即可。注意这样的类不能作为基类，也不能被其他类包含。