对象复制和分配的控制

将析构函数声明成私有就可以避免堆栈和全局分配，还能防止不谨慎的时候delete, 控制派生：

#include <iostream>
class On_free_store
{
private :
    ~On_free_store(); //private destrctor
public :
    static void free(On_free_store *p) { delete p; }
};
//On_free_store globl; //error : private destructoor
class D : public On_free_store
{
 
};
void f()
{
 //On_free_store loc; //error : private destructor
 On_free_store *p = new On_free_store;
 //...
 //delete p; //error : private destructor
 On_free_store::free(p);
 D d;    //error : cannot call private base class destructor
}
int main()
{
 system("PAUSE");
 return 0;
}

为什么不能分配全局和进行堆栈呢？因为全局变量和在栈中的临时对象，都是程序自动调用析构函数销毁的，但是这里的析构函数是私有的，所以会出错，同时也无法随便的使用delete来销毁自由分配的对象。但是On_free_store类的静态函数free却有调用析构函数的权限，因此可以通过调用free来销毁自由分配的对象。

如果想只分配全局和堆栈变量，禁止自由空间分配也用同特殊的new运算符重载。

对象的复制：

对象的复制被定义成对所有非静态成员和基类成员的按成员复制。换句话说，就是x=y实际上就是x.operator(y)。

切片：

class X { /*..........*/ };

class Y : public X { /*.............*/ };

void g(X x, Y y)

{

    x = y;    //x.operator(y)

    y = x;    //y.operator(x) : error x is not a Y

}

按照默认的方式，对X的赋值就是对函数x.operator = (const X&)的调用，所以x = y是合法的因为Y是X的派生类。这样的情况称为切片（y的一部分赋值给了x）。复制构造函数也按类似的方式处理。

对象复制的控制：
如果想禁止对象的复制，可以简单的把复制构造函数和赋值运算符函数定义为私有：

class X

{

private :

    X& operator =(const X&);    //assignment

    X(const X&);                         //copy constructot

    //...

public:

    X(int);                                    //constructor

};