《More Effective C++》技术篇——要求（或禁止）对象产生于heap之中

• 要求对象产生于heap中，意思是需要阻止clients不得使用new以外的方法产生对象。比较好的方法就是将destructor定义为private，因为constructor的类型太多，所以仍然将constructor定义为public。然后定义一个pseudo destructor来调用真正的destructor。示例如下：

  class HeapBasedObject {
  public:
    HeapBasedObject() {}
    void destroy() const { delete this; } // pseudo destructor
  
  private:
    ~HeapBasedObject() {}
  };
  
  int main()
  {
    //HeapBasedObject h;
    HeapBasedObject *ph = new HeapBasedObject;
    //delete ph;
    ph->destroy();
  }

• 禁止对象产生于heap中，则是要让clients不能使用new方法来产生对象。方法就是将operator new和operator delete定义为private。示例如下：

  #include <stdlib.h>
  
  class NoHeapBasedObject {
  public:
    NoHeapBasedObject() {}
    ~NoHeapBasedObject() {}
  
  private:
    static void *operator new(size_t size) {}
    static void operator delete(void *ptr) {}
  };
  
  int main()
  {
    NoHeapBasedObject nh;
    static NoHeapBasedObject snh;
    //NoHeapBasedObject *pnh = new NoHeapBasedObject;
  }

• 下例是实现的一个判断某个对象是否位于heap内的基类HeapTracked。

  #include <stdlib.h>
  #include <list>
  #include <iostream>
  
  class HeapTracked {
  public:
    class MissingAddress{}; //地址异常
    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 std::list<RawAddress> addresses;
  };
  
  std::list<HeapTracked::RawAddress> HeapTracked::addresses;
  
  HeapTracked::~HeapTracked() {}
  
  void* HeapTracked::operator new(size_t size) {
    void* memPtr = ::operator new(size); // 取得内存。
    addresses.push_front(memPtr); // 将其地址置于list头部。
    return memPtr;
  }
  
  void HeapTracked::operator delete(void *ptr) {
    auto it = std::find(addresses.begin(), addresses.end(), ptr);
  
    if (it != addresses.end()) {
        addresses.erase(it);
        ::operator delete(ptr);
    } else {
        throw MissingAddress();
    }
  }
  
  bool HeapTracked::isOnHeap() const {
    auto rawAddress = dynamic_cast<const void*>(this);
  
    auto it = std::find(addresses.begin(), addresses.end(), rawAddress);
    
    return it != addresses.end();
  }
  
  class Object: public HeapTracked {
  public:
    Object() {}
    ~Object() {}
  };
  
  
  int main()
  {
    Object o1;
    Object* o2 = new Object;
    std::cout << "o1 isOnHeap = " << o1.isOnHeap() << std::endl;
    std::cout << "o2 isOnHeap = " << o2->isOnHeap() << std::endl;
  }