条款08：别让异常逃离析构函数

以下是一个将（必须要求调用的）close()函数置于析构函数内的demo：

#include<iostream>

class DtorExcetion{
public:
    DtorExcetion()=default;
    DtorExcetion(int*data,const int&length)
        :m_length(length)
        {
            m_data=new int[m_length];
            for(int i=0;i<m_length;++i){
                m_data[i]=data[i];
            }
            std::cout<<"Ctor successfully!"<<std::endl;
        }
    ~DtorExcetion()=default;
    friend class DBconn;
private:
    void close(bool& ifclose){
        std::cout<<"Please select 1-close,other-excetion:";
        int select;
        try{
            std::cin>>select;
            if(select==1){
                std::cout<<"Close successfully!"<<std::endl;
                ifclose=true;
            }else{
                throw("Close false!");
            }  
        }
        catch(const char*&msg){
            std::cout<<msg<<std::endl;
            std::cout<<"Got exction!"<<std::endl;
            std::abort();}
        delete []m_data;
        m_data=nullptr;
        std::cout<<"Relese m_data successfully!"<<std::endl;
    }//close()用于释放m_data并假设必须得调用
private:
    int*m_data;
    int m_length;
};

class DBconn{
public:
    DBconn(const DtorExcetion&dtor){
        this->obj=dtor;
    }
    ~DBconn(){
        if(!this->ifclose){
            obj.close(this->ifclose);
        }
        std::cout<<"Dtor successfylly!"<<std::endl;
    }
    void close(){
        obj.close(this->ifclose);
    }
private:
    DtorExcetion obj;
    bool ifclose=false;
};//用该对象的析构函数来调用close()函数

析构函数中抛出异常将导致“草率结束程序”或“不明确行为带来的风险”，在此demo中，将导致m_data资源无法释放。

请记住：

析构函数绝对不要吐出异常。如果一个被析构函数调用的函数可能抛出异常，析构函数应该捕捉任何异常，然后吞下它们（不传播）或结束程序。
如果客户需要对某个操作函数运行期间抛出的异常作出反应，那么class应该提供一个普通函数（而非在析构函数中）执行该操作。

条款09：绝不在构造和析构过程中调用virtual函数

class Transaction{//所有交易的base class
public:
    Transaction(){
        ...
        logTransaction();
    }
    virtual void logTransaction() const =0;//作出一份因类型不同而不同的日志记录
};

class BuyTransaction:public Transaction{
public:
    virtual void logTransaction() const;
    ...
};

class SellTransaction:public Transaction{
public:
    virtual void logTransaction() const;
    ...
};

该段代码意在利用多态性，根据生成的不同交易类型的对象，生成不同的日志记录。然而忽略了构造的顺序，logTransaction函数在Transaction内是个pure virtual，连接器找不到Transaction::logTransaction实现代码

derived class对象内的base class成分会在derived class自身成分被构造之前先构造妥当
base class构造期间virtual函数不会下降到derived classes阶层
derived class对象的base class构造期间，对象的类型是base class而不是derived class——这个对象内的derived专属成分尚未被初始化，最安全的做法是视它们不存在

在class Transaction内将logTransaction函数改为non-virtual,然后要求derived class构造函数传递必要信息给Transaction构造函数，代码如下：

class Transaction{
public:
    explicit Transaction(const std::string&logInfo){
        ...
        logTransaction(logInfo);
    }
    void logTransaction(const std::string&loginfo) const;
};

class BuyTransaction:public Transaction{
public:
    BuyTransaction(parmeters)
        :Transaction(createLogString(parmeters))
        {...}
private:
    static std::string createLogString(parameters);
};