More Effective C++之27

条款27：要求（或禁止）对象产生于heap之中

要求对象产生于Heap之中 Heap-Based Objects

       考虑如下代码：

class HeapClass

{

public :

       void Destory () const { delete this ;}

private :

       ~ HeapClass (){}

};

HeapClass * ptr = new HeapClass ;

ptr -> Destory ();

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

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

 

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

考虑如下代码：

new HeapClass (* new HeapClass );

你觉得编译器应该怎么做？
1.调用operator new
2.调用Constructor
3.调用第二个operator new
4.调用第二个Constructor

但是可以让人足够惊讶，编译器对此并不做承诺，所以实际的实现可能是
1.调用operator new
2.调用第二个operator new
3.调用Constructor
4.调用第二个Constructor

我知道VC6是这样实现的。

class HeapClass

{

private :

      

       void * operator new []( size_t size );

       typedef const void * RawAddress ;

       void operator delete []( void * ptr );

public :

       void operator delete ( void * ptr )

          {

                 printf ( "delete/n" );

                 :: operator delete ( ptr );

                 m_address . erase (
                    std :: remove ( m_address . begin (), m_address . end (), ptr ), m_address . end ());

                 return ;

          }

       void * operator new ( size_t size )

          {

                 printf ( "new/n" );

                 void * ptr = :: operator new ( size );

                 m_address . push_back ( ptr );

                 return ptr ;

          }

       HeapClass ()

       {

              printf ( "Constructor!/n" );

       }

       HeapClass ( const HeapClass &)

       {

              printf("copy Constructor!/n");

       }

       virtual void Destory () const { delete this ;}

       virtual ~ HeapClass () = 0;

       bool isOnHeap () const

       {

//            const void * rawAddress = dynamic_cast<const void *>(this);

              const void * rawAddress = ( const void *)( this );

              std :: deque < RawAddress >:: iterator iter = std :: find ( m_address . begin (), m_address . end (), rawAddress );

              return iter != m_address . end ();

       }

private :

       static std :: deque < RawAddress > m_address ;

};

 

HeapClass ::~ HeapClass (){}

std :: deque < HeapClass :: RawAddress > HeapClass :: m_address ;

class DHeapClass : public HeapClass

{

};

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

 

禁止对象产生于heap之中

       考虑如下代码

class HeapClass

{

private :

       void * operator new ( size_t size );

       void * operator new []( size_t size );

void operator delete ( void * ptr );

void operator delete []( void * ptr );

public :

       HeapClass (){ printf ( "Constructor!/n" );}

       HeapClass(constHeapClass&){printf("copy Constructor!/n");}

public :

       ~ HeapClass (){}

};

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