控制C++的类只能在堆分配或只能在栈分配

 

//HeapOnly.cpp  

  #include   <iostream>  
  using   namespace   std;  
   

 

只能在堆上分配空间：我们可将类的析构函数用private来修饰，也就是把析构函数私有化，因为自动变量与静态变量的对象都在释放空间的时候都需要访问析构函数。若析构函数私有，外面就不能调用，这时候会产生编译错误，这样就达到了只能在堆上分配空间了。但是，把析构函数私有化，那么我们就不能调用delete了， 因为它也需要访问析构函数。这就要求我们自己去提供回收内存空间的函数，以防内存泄漏。
  class   HeapOnly  
  {  
  public:  
  HeapOnly()   {   cout   <<   "constructor."   <<   endl;   }  
  void   destroy   ()   const   {   delete   this;   }  
  private:  
  ~HeapOnly()   {}    
  };  
   
  int   main()  
  {  
  HeapOnly   *p   =   new   HeapOnly;  
  p->destroy();  
  // HeapOnly   h;  
  // h.Output();  
   
  return   0;  
  }  
  //StackOnly.cpp  
  //2005.07.18------2009.06.05  
  #include   <iostream>  
  using   namespace   std;  

只能在栈上分配空间：可将 T:: operator new 全部私有，因为要在堆上分配空间，需要用到new来实现，当你把new私有化，我们就不能调用new T()这样的语句，这样可以达到只能在栈上来分配空间了。   

  class   StackOnly  
  {  
  public:  
  StackOnly()   {   cout   <<   "constructor."   <<   endl;   }  
  ~StackOnly()   {   cout   <<   "destructor."   <<   endl;   }  
  private:  
  void*   operator   new   (size_t);  
  };  
   
  int   main()  
  {  
  StackOnly   s;                                                             //okay  
  StackOnly   *p   =   new   StackOnly;                           //wrong  
   
  return   0;  
  }

 

在类设计中，类的成员如果是在栈中，那么也需要显识地在类的析构函数中调用成员的析构函数，否则就会造成内存泄露

转载于:https://www.cnblogs.com/cplover/p/3371946.html