对象只能创建在堆上

#include <iostream>
using namespace std;
//如何禁止在栈上创建对象
//1.将构造函数设置为私有 --错误 将无法创建对象 A a; new class A;都会报错 因为构造是私有的 编译器无法调用
//2.将析构函数设置为私有 --正确 析构是私有的 用户无法调用析构释放内存 会产出内存泄漏 需要自行提供释放内存的方法
//                              delete this;delete会调用析构 因为在类内部 可以调用析构
//解析：
//      当对象创建在栈上的时候，由编译器管理对象的整个生命周期
//      将析构函数设置为私有，在栈上创建对象A a;编译器会检查对象的构造和析构是否正常，因为析构是私有，所以编译器
//      无法分配内存给这个对象。
class A{
        public:
                A(){cout << "A()" << endl;};
                //~A(){};
                void destory(){delete this;}
                void play(){
                        cout << "play" << endl;
                }
                int m_pub = 11;
        protected:
                ~A(){cout << "~A()" << endl;}
                int m_pro = 12;
        private:
                //~A(){cout << "~A()" << endl;}
                int m_pri = 10;
};
//优化
//如果子类需要继承A 那么A的析构必须是虚析构
class B : protected A
{
        public:
                B(){cout << "B()" << endl;}
                void play1(){cout << "A = " << m_pub << endl;}
                void play2(){
                        cout << "A pro = " << m_pro << endl;
                }
};

//对象只能创建在栈上
//只有使用new运算符，对象才会建立在堆上，因此，只要禁用new运算符就可以实现类对象只能建立在栈上。将operator new()设为私有即可
class C
{
        public:
                void play()
                {cout << "play c" << endl;}
        private:
                void * operator new(size_t size);
                void operator delete(void *p);
};
int main()
{
        //析构是私有的 在栈上创建 会报错error: ‘A::~A()’ is private within this context
        //class A a;
        //a.play();
        class A *a = new class A();
        a->play();
        a->destory();

        class B b;
        b.play1();
        b.play2();

        class C c;
        c.play();

        //‘static void* C::operator new(size_t)’ is private within this context
        //class C *d = new class C;
        return 0;
}