只在堆，或者只在栈上建立对象

在C++中,类对象的建立分为两种:静态建立(A a)和动态建立(A* ptr = new A)。
1.静态建立对象:是由编译器为对象在栈空间中分配内存。使用这种方法,直接调用类的构造函数,当使用完了后,编译器自动调用析构函数对这片栈内存进行释放。
2.动态建立对象:是使用new运算符将对象建立在堆空间中。这个过程分为两步:a.编译器执行operator new()函数,在堆空间中搜索合适的内存并进行分配;b.调
用构造函数构造对象,初始化这片内存空间。属于是间接调用类的构造函数,当对象调用完毕后delete也会调用析构函数对堆上的内存进行释放。
------------------如何限制类对象只能在堆或者栈上建立呢？-----------------
一.先来看看只能在堆上分配类对象吧！
只能在堆上分配对象,就是不能建立静态类对象,即不能直接调用类的构造函数。
a.最容易想到的是将构造函数设置为私有,在构造函数私有以后,无法在类的 外部调用构造函数来构造对象,只能使用new运算符来建立对象。然而,我们已经知道,
new运算符分为两步。C++提供new运算符的重载,其实是只允许重载opetator new()函数,而operator new()函数只分配内存,无法提供构造功能。因此,这种方法是不可
以的。
b.当对象建立在栈上面时,是由编译器分配内存空间的,调用构造函数来构造对象,当对象使用完毕后,编译器会调用析构函数来释放栈对象所占的内存空间,编译
器管理了对象的整个生命周期。如果编译器无法调用析构函数,将会怎么样呢？比如,类的析构函数是私有的,编译器无法调用析构函数来释放内存。所以:编译器在为类对
象分配栈空间时,先会检查类的所有析构函数的访问性,如果类的析构函数是私有的,则编译器不会在栈空间上为类的对象分配内存。
因此,将析构函数设为私有,类对象就无法建立在栈上了。看个例子吧:

> ```class A {   	public:  
> 	    A(){}  
> 	    void destory(){delete this;}   	private:  
> 	    ~A(){}   };    ```

试着用A a来建立对象,编译报错,提示析构函数无法访问。这样就只能通过new关键字符来建立对象,构造函数是共有的,可以直接调用。但是类中必须提供一个

destory()函数,来进行内存空间的释放。类对象使用完毕后,必须调用destory()函数。
但是呢？将析构函数设置为私有的缺陷:
Ⅰ.无法解决继承问题。如果类A作为其它类的基类,我们通常要将析构函数设置为virtual,然后在子类重写,以实现多态,目的是为了释放子类中的所有资源,否
则会释放不干净。还好C++提供了protected,将析构函数设为protected可以有效解决这个问题,类外无法访问protected成员,子类则可以访问。
Ⅱ. 类的使用很不方便,使用new建立对象,却使用destory释放对象,而不是使用delete。(使用delete会报错,因为delete对象的指针,会调用对象的析构函数,
而析构函数类外不可以访问),这种使用方式比较怪异。为了统一,可以将构造函数设为protected,然后提供一个public的static函数来完成构造,这样不使用new,而是使
用一个函数来构造,使用一个函数来析构。

> lass A {   	protected:  
> 	    A(){}  
> 	    ~A(){}   	public:  
> 	    static A* create(){  
> 	        return new A();  
> 	    }  
> 	    void destory(){  
> 	        delete this;  
> 	    }   };

这样,调用create()函数在堆上创建类A对象,调用destory()函数释放内存。

二.再来看看只能在栈上分配类对象吧！
只有使用new运算符,对象才会在堆上建立,因此,只要禁用new运算符就可以实现类对象只能建立在栈上。因此,可以将operator new()设为私有即可禁止对象被new在
堆上。

class A {  
private:  
    void* operator new(size_t t){}     // 注意函数的第一个参数和返回值都是固定的  
    void operator delete(void* ptr){} // 重载了new就需要重载delete  
public:  
    A(){}  
    ~A(){}  
};  

Conclusion:思考:在栈上和堆上建立对象的相同点和不同点？
相同点:无论是A a还是A* a = new A();都会由编译器在类外部调用类的构造函数来创建对象,同样在释放内存空间时也是会由编译器调用类的析构函数来释放。
不同点:
1:栈对象创建过程中,分配内存然后调用构造函数;对象释放过程中,释放内存然后析构函数的调用都是编译器自动完成的。
2:而堆对象的创建过程中需要先由编译器显式的调用operator new()函数进行内存分配然后调用构造函数,堆的释放过程中需要先由编译器显式的调用
operator delete()函数,然后编译器自动调用析构函数。
1:为了只能在栈上创建对象,那么我们就可以将operator new()函数和operator delete()函数进行重载,这两个函数不做任何事情不分配内存,并将他们设
置为private,那么编译器就无法调用这两个函数。也就不能再堆上创建对象了,此时的构造函数和析构函数还是可以被编译器自由的调用创建栈对象。
2:为了只能在堆上创建对象,那么我们就必须让编译器不能自动调用构造函数和析构函数(虽然编译器能够自动分配内存但是没有调用构造函数,栈对象就没办
法创建完成)。所以将构造函数和析构函数都设置为protected,这样编译器就不能调用了,但是创建堆对象也要由编译器调用构造函数和析构函数怎么办呢?得益于堆对象
的创建过程需要调用类中定义的函数,那么我们可以定义两个函数create和destroy函数分别在内部调用构造函数和析构函数,这样就可以由编译器在堆上创建和释放对
象。