c++编程 别让异常逃离析构函数，绝不在构造和析构过程中调用virtual函数

别让异常逃离析构函数

在C++中，析构函数应该确保在执行过程中不会抛出异常。如果析构函数中可能抛出异常，那么应该捕获并处理这些异常，或者确保异常不会向上传播。
如果不禁止析构函数抛出异常，在析构函数中抛出异常很容易导致内存泄漏（程序过早结束）
为了避免异常逃离析构函数，可以采取以下方法：
在析构函数中捕获所有可能的异常，并将其设置为默认处理方式（例如，记录错误并结束程序）

c++
#include <iostream>
#include <string>
#include <exception>
#include <stdlib.h>
#include <regex>
using namespace std;
/* 实验一： 验证析构函数抛出异常的问题 */
namespace  experiment1 {
    class DBConnection {
    public:
        //这个函数返回一个 DBConnection对象；
        static DBConnection create() {
            DBConnection db;
            return db;
        }
        //关闭联机，失败时抛出异常
        void close() {
            throw "Unknown Exception";  //抛出异常
        }
    };

//RTII: 创建一个用来管理DBConnection资源的 class ，并在其析构函数调用 close
    class DBConnManager {
    private:
        DBConnection m_db;
        char *m_pt;
    public:
        explicit DBConnManager(DBConnection db)
                :m_db(db)
        {
            m_pt = (char *)malloc(10);
        }


        ~DBConnManager() {
            m_db.close();
            if(m_pt !=NULL){
                free(m_pt);
            }

        }
    };

    void Test() {
        DBConnManager dbc(DBConnection::create());
        //这里我们做一个评测
        /* 如果当dbc析构时调用close顺利，一切美好
         * 如果抛出异常， DBConnManager析构函数就会过早结束，并传播该异常（此时连接未关闭），会导致一定问题
         */
        cout<<"end Test"<<endl;
    };
}

int main(){
    experiment1::Test();
    cout<<"end"<<endl;
    return 0;
}

执行结果：

end Test
terminate called after throwing an instance of 'char const*'
已放弃 (核心已转储)

valgrind 检查：

  1 ==2503== Memcheck, a memory error detector
  2 ==2503== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
  3 ==2503== Using Valgrind-3.19.0 and LibVEX; rerun with -h for copyright info
  4 ==2503== Command: ./test
  5 ==2503== Parent PID: 283
  6 ==2503==
  7 ==2503== error calling PR_SET_PTRACER, vgdb might block
  8 ==2503==
  9 ==2503== Process terminating with default action of signal 6 (SIGABRT): dumping core
 10 ==2503==    at 0x4AA400B: raise (raise.c:51)
 11 ==2503==    by 0x4A83858: abort (abort.c:79)
 12 ==2503==    by 0x4902910: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
 13 ==2503==    by 0x490E38B: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
 14 ==2503==    by 0x490D368: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
 15 ==2503==    by 0x490DD20: __gxx_personality_v0 (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
 16 ==2503==    by 0x4A56BEE: ??? (in /usr/lib/x86_64-linux-gnu/libgcc_s.so.1)
 17 ==2503==    by 0x4A57280: _Unwind_RaiseException (in /usr/lib/x86_64-linux-gnu/libgcc_s.so.1)
 18 ==2503==    by 0x490E69B: __cxa_throw (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.28)
 19 ==2503==    by 0x109411: experiment1::DBConnection::close() (test08.cpp:26)
 20 ==2503==    by 0x109455: experiment1::DBConnManager::~DBConnManager() (test08.cpp:45)
 21 ==2503==    by 0x1092C9: experiment1::Test() (test08.cpp:54)
 22 ==2503==
 23 ==2503== HEAP SUMMARY:
 24 ==2503==     in use at exit: 73,362 bytes in 4 blocks
 25 ==2503==   total heap usage: 5 allocs, 1 frees, 73,378 bytes allocated
 26 ==2503==
 27 ==2503== LEAK SUMMARY:
 28 ==2503==    definitely lost: 0 bytes in 0 blocks
 29 ==2503==    indirectly lost: 0 bytes in 0 blocks
 30 ==2503==      possibly lost: 0 bytes in 0 blocks
 31 ==2503==    still reachable: 73,362 bytes in 4 blocks
 32 ==2503==         suppressed: 0 bytes in 0 blocks
 33 ==2503== Reachable blocks (those to which a pointer was found) are not shown.
 34 ==2503== To see them, rerun with: --leak-check=full --show-leak-kinds=all
 35 ==2503==
 36 ==2503== For lists of detected and suppressed errors, rerun with: -s
 37 ==2503== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

执行结果显示：

void close() {
            throw "Unknown Exception";  //抛出异常
        }

这个异常没有捕获， 系统发出SIGABRT信号导致程序提前结束， m_pt内存没有被释放。
总结：

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

绝不在构造和析构过程中调用virtual函数

在C++中，构造函数和析构函数是类的特殊成员函数，它们在对象创建和销毁时被自动调用。为了避免在构造和析构过程中调用virtual函数，可以采取以下方法：

1. 将virtual函数转换为非virtual函数。将需要virtual函数的功能实现放在一个非virtual函数中，然后在构造函数中调用这个非virtual函数。在析构函数中不需要调用virtual函数，因为编译器会自动处理这种情况。

class MyClass {
public:
    MyClass() {
        // 调用非virtual函数实现
        nonVirtualFunction();
    }

    ~MyClass() {
        // 无需调用virtual函数
    }

private:
    void nonVirtualFunction() {
        // 实现需要virtual函数的功能
    }
};

2. 将virtual函数转换为静态成员函数。将需要virtual函数的功能实现放在一个静态成员函数中，然后在构造函数中调用这个静态成员函数。在析构函数中不需要调用virtual函数，因为编译器会自动处理这种情况。

#include <iostream>
/* 实验一： 证明在 base class 构造期间， virtual 函数不是 virtual 函数。*/
namespace experiment1 {
    class Transaction {
    public:
        Transaction();
        virtual void logTransaction() const { std::cout << "transaction" << std::endl; }
    };
    Transaction::Transaction() {
        logTransaction();
    }

    class BuyTransaction: public Transaction {
    public:
        virtual void logTransaction() const override { std::cout << "BugTransaction" << std::endl; }
    };
    class SellTransaction: public Transaction {
    public:
        virtual void logTransaction() const override { std::cout << "SellTransaction" << std::endl;}
    };

    void Test() {
        BuyTransaction b;  //调用的是base class 的虚函数 logTransaction
        // 原因1： 如果在构造base class时调用的是 derived class 的函数（会使用到derived class成员，
        // 但此时成员都是未构造的，会出现问题）
        // 原因2： 在derived class对象的 base class构造期间，对象本身是base class而不是 derived class
        // 不止virtual函数会被编译器解析至 base class，运行期类型信息，也会把对象视为 base class
        //相对应析构函数执行到base class部分，编译器也会视当前对象为 base class
    }

}
int main(){
    experiment1::Test();
    return 0;
}

执行结果：

$ ./test
transaction

原因：
1.构建BuyTransaction对象时，先调用Transaction的构造函数，这个时候， virtual void logTransaction() 并不会调用到BuyTransaction这个的实现
而是作为Transaction 一部分， 即构造期间，virtual函数并不是virtual函数。
2. 构造期间 BuyTransaction b

总结
在base class 构造和析构期间不要调用 virtual 函数，因为这类调用从不下降至 derived class
(比起当前执行构造函数和析构函数那层)，virtual本质上并没有用