只能在栈上或者堆上创建对象

只允许对象生成于堆内？怎么理解？肿么办？

假如，手头上有一个类Person，当你在程序中写下Person rn时，

编译器悄悄地做了两件事：调用constructor构造对象rn，而在弹栈时，调用destructor析构对象rn。

对象rn的构造和析构全部由编译器负责，这是栈的特性！

诸所周知，对象rn生成于栈内。

而我们现在的要求是什么？“只允许对象生成于堆内。”rn明显违背了我们的要求，也就意味着它应该被禁止。


那这种 “坑爹型”的事情肿么办呢？有人想说，只要让Person的构造函数或者析构函数成为private就OK了。

也许许多人真会有这样的第一想法，假使那样，咱再往下进一步思考。

如果那样的话，这个类可以实现继承吗？No，即就是禁止继承。

另外，这个类允许其他类拥有它的对象吗？No，即就是禁止包含。

那怎么办呢？ 解决的方法也很简单，解除继承的副作用只需让Person的析构函数成为protected就可以了；

解决内含的副作用只需让Test中的成员变量ps成为Person*类型并在Test的构造/析构函数中对成员变量做初始化和释放操作就可以了。

本例完整的代码如下所示。
#include<iostream>
using  namespace std;

class Person
{
public:
    Person()
    {
        cout<<"Con()"<<endl;
    }
    Person(int x)
    {
        a = x;
        cout<<"Con(x)"<<endl;
    }
    void  Destroy()
    {
        delete this;
    }

protected:
    ~Person()
    {
        cout<<"Des"<<endl;
    }
private:
    int a;
};

class  Student:public Person
{

};

class Test
{
public:
    Test()
    {
        ps = new  Person();    //堆上对象
    }
    ~Test()
    {
        ps->Destroy();
    }
private:
    Person *ps;
};

void main()
{
    Test t1;
}
转载自：http://www.cnblogs.com/Braveliu/archive/2013/01/06/2847475.html

只能在堆上创建对象
C++中存放变量的地方有三个，分别是全局/静态变量存储区，局部变量存储区
即栈，new存放的变量存放在堆上，解题的思路是：
如果只在栈上创建对象则禁止在堆上创建，重写operator new 和operator delete
如果只在堆上创建对象则把析构函数定义为私有的，但是一定要定义一个函数把new的
对象删除掉 void distory () const 
  {

   delete this;

}
#include <iostream>
using namespace  std;

class A
{
public:
    
     A()
    {

        cout<<"dhjj"<<endl;
    }
     void distory () const  //通过公有接口访问私有的析构函数
     {

         delete this;
     }
    
private :

     ~A(){ cout<<"this";}
    
    

};
int main()
{


    A* a=new A;
    a->distory();
    
    return 0;
}

只能在栈上创建对象
#include <iostream>
using namespace  std;

class A
{
public:
 
  A()
 {

  cout<<"dhjj"<<endl;
 }
 
  ~A(){ cout<<"this";}
private:
 void* operator new (size_t t); 
 void  operator delete(void *ptr);   

 
 

};
int main()
{


 A* a=new A;
 A a;
 
 return 0;
}

 

 转载自：http://blog.csdn.net/acdnjjjdjkdckjj/article/details/5633611