C++中要求(或禁止)对象产生于heap中

要求对象产生于Heap之中

   考虑如下代码:

classHeapClass
{
  public:
   voidDestory() const {deletethis;}
  private:
   ~HeapClass(){}
};
HeapClass* ptr = newHeapClass;
ptr->Destory();

   这样的调用真是很厉害,想生成非Heap对象都不成了。

   对于继承和组合的情况不想多说了,比较无趣的说。

判断某个对象是否位于Heap内

   考虑如下代码:

newHeapClass(* newHeapClass);
   你觉得编译器应该怎么做?

   1.调用operator new

   2.调用Constructor

   3.调用第二个operator new

   4.调用第二个Constructor

   但是可以让人足够惊讶,编译器对此并不做承诺,所以实际的实现可能是:

   1.调用operator new

   2.调用第二个operator new

   3.调用Constructor

   4.调用第二个Constructor

   而VC6是这样实现的。

classHeapClass
{
  private:
   void* operatornew[](size_tsize);
   typedefconstvoid * RawAddress;
   voidoperatordelete[](void* ptr);
  public:
   voidoperatordelete(void *ptr)
   {
    printf(“delete\n”);
    ::operatordelete(ptr);
    m_address.erase(std::remove(m_address.begin(),m_address.end(),ptr),m_address.end());
    return;
   }
   void* operatornew(size_tsize)
   {
    printf(“new\n”);
    void * ptr = ::operatornew(size);
    m_address.push_back(ptr);
    returnptr;
   }
   HeapClass()
   {
    printf(“Constructor!\n”);
   }
   HeapClass(constHeapClass&)
   {
    printf(“copy Constructor!\n”);
   }
   virtualvoidDestory() const {deletethis;}
   virtual ~HeapClass() = 0;
   boolisOnHeap() const
   {
    // const void * rawAddress = dynamic_cast<const void *>(this);
    constvoid * rawAddress = (constvoid *)(this);
    std::deque<RawAddress>::iteratoriter = std::find(m_address.begin(),m_address.end(),rawAddress);
    returniter != m_address.end();
   }
   private:
    staticstd::deque<RawAddress> m_address;
  };

  HeapClass::~HeapClass(){}
  std::deque<HeapClass::RawAddress> HeapClass::m_address;
  classDHeapClass:publicHeapClass
  {};

   我在VC6中写了这个Demo测试了一下,但是const void * rawAddress = dynamic_cast<const void *>(this);会出现异常,这让我觉得很郁闷,所以这个Demo只能支持普通的继承方式,不支持多种继承和虚拟继承。

禁止对象产生于heap之中

   考虑如下代码:

classHeapClass
{
  private:
   void* operatornew(size_tsize);
   void* operatornew[](size_tsize);
   voidoperatordelete(void *ptr);
   voidoperatordelete[](void* ptr);
  public:
   HeapClass(){printf(“Constructor!\n”);}
   HeapClass(constHeapClass&){printf(“copy Constructor!\n”);}
  public:
   ~HeapClass(){}
};

   这确实是比较简单的事情。