析构函数 Destructor

析构函数 Destructor

　　当一个对象的生命周期结束（超出范围或者主动释放）时，

　　调用对象的析构函数来回收其所占用的存储空间（对象，动态内存等）和资源（信号量，互斥锁等）。

一 普通虚构函数

class ConcreateObject: public object
{
public:
    ~ConcreateObject();
};

//使用 范围
{
    ConcreateObject cObj;
}   
------------->//cObj生命结束 析构函数被调用  ~ConcreateObject()

//手动释放
ConcreateObject *pCObj = new ConcreateObject();
delete pCObj;     //析构函数被调用  ~ConcreateObject() ~object() 

二 protected 类型 析构函数

class ConcreateObject: public object
{
protected:
    ~ConcreateObject();     //析构函数为protected类型
};

//使用

ConcreateObject cObj;       //error  无法在栈上创建对象

ConcreateObject *pCObj = new ConcreateObject();         //right
delete pCObj;               //error 析构函数为protected 无法直接访问

三 private 类型 析构函数

class ConcreateObject: public object
{
private:
    ~ConcreateObject();
};

//使用

ConcreateObject cObj;       //error  无法在栈上创建对象
ConcreateObject *pCObj = new ConcreateObject();         //right
delete pCObj;               //error 析构函数为protected 无法直接访问

class ConcreateObjectA: public ConcreateObject
{
    ~ConcreateObjectA()
    {                 //error 基类析构函数private属性成员函数无法被继承 
    }
};

四 virtual 类型 虚函数

class base
{
public :
    base()
    {
        m_pNum = new int(20);
    }
    ~base()
    {
        delete m_pNum;
    }
private:
    int * m_pNum;
};
class object
{
public:
    ~object();                      //基类析构函数为 非虚函数
};

class ConcreateObject: public object
{
protected:
    ~ConcreateObject();

    base m_base;
};

//使用
ConcreateObject *pCObj = new ConcreateObject();         //使用父类对象指针释放内存 父类析构函数为 非虚函数
object* pObj = (object*)pCObj;
delete pObj;                    

    //仅~object()被调用 基类析构函数 非虚函数 对象仍旧被释放 但是实际类型Concreate析构函数及其类成员对象没有释放内存，析构函数得不到执行

class object
{
public:
    virtual ~object();             //基类析构函数为 虚函数
};

//使用父类对象指针释放内存父类析构函数为 虚函数
object* pObj = (object*)pCObj;
delete pObj;                    
    //~ConcreateObject(),~base(),~object()在执行~ConcreateObject()时成员的然后基类的析构函数被调用  基类析构函数虚函数 对象仍旧被释放

　　作为基类的析构函数的属性（是否为virtual）需要仔细斟酌。

　　具有虚函数的类是需要为其创建虚函数表存储虚函数地址，需要额外的分配存储空间。

五 析构函数为纯虚函数

class object
{
public:
    virtual ~object() = 0;           //基类虚函数为纯虚函数
};

class ConcreateObject: public object
{
protected:
    ~ConcreateObject();

    base m_base;
};

class ConcreateObjectA: public ConcreateObject
{
protected:
    ~ConcreateObject();
};

//使用
object obj;               //error 抽象类无法创建对象
ConcreateObject *pCObj = new ConcreateObject(); 

//去掉 实例化 抽象的基类 对象 
ConcreateObject *pCObj = new ConcreateObject();     //link error 基类纯虚析构函数必须实现 才能被继承

class object
{
public:
    virtual ~object() = 0{}    //基类纯虚析构函数 需要被实现
};
object obj;                //right 实现之后 可以创建对象

　　一个类的析构函数置成纯虚函数，可以保证不被实例化。

　　如果此类需要被继承，仍然需要被实现此纯虚析构函数

　　这样一来，纯虚函数 已经失去了意义。