#include 
    
     using namespace std;//只能在堆内存上实例化的类class CHeapOnly{public:
     
CHeapOnly()
     
{
     
cout << "Constructor of CHeapOnly!" << endl;
     
}
     
void Destroy() const
     
{
     
delete this;
     
}private:
     
~CHeapOnly()
     
{
     
cout << "Destructor of CHeapOnly!" << endl;
     
}};//只能在栈内存上实例化的类，就是不能使用new来构造类，把operator new私有化class CStackOnly{public:
     
CStackOnly()
     
{
     
cout << "Constructor of CStackOnly!" << endl;
     
}
     
~CStackOnly()
     
{
     
cout << "Destrucotr of CStackOnly!" << endl;
     
}private:
     
void* operator new(size_t size)
     
{
     
}
     
void operator delete(void * ptr)
     
{
     
}};int main(){
     
//use of CHeapOnly
     
CHeapOnly* pHeap = new CHeapOnly;
     
pHeap->Destroy();
     
//error use of CHeapOnly
     
//CHeapOnly objHeap;
     
//use of CStackOnly
     
CStackOnly objStack;
     
//error use of CStackOnly
     
//CStackOnly* pStack = new CStackOnly;
     
return 0;}
    

#include 
    
     using namespace std;//只能在堆内存上实例化的类class FinalClass{public :
     
static FinalClass* GetInstance()
     
{
     
cout<<"Constructor of the class"<
     
      
return new FinalClass;
      
}
      
static void DeleteInstance(FinalClass* pInstance)
      
{
      
cout<<"Destructor of the class"<
      
       
delete pInstance;
       
pInstance = 0;
       
}private :
       
FinalClass() {}
       
~FinalClass() {}};int main(){
       
//use of CHeapOnly
       
FinalClass* fc = FinalClass::GetInstance();
       
FinalClass::DeleteInstance(fc);
       
return 0;}