C++构造函数和析构函数调用顺序

构造函数和析构函数调用顺序

• 构造函数
  • 基类中对象成员的构造函数
  • 基类的构造函数
  • 派生类中对象成员的构造函数
  • 派生类的构造函数
• 析构函数
  • 派生类的析构函数
  • 派生类中对象成员的析构函数
  • 基类的析构函数
  • 基类中对象成员的析构函数

析构函数和构造函数的调用顺序恰好相反。

以上是常规情况，当我们让基类指针指向派生类对象时，情况会出现不同：

• 若基类析构函数不是virtual的，那会依次调用 ：

  • 基类中对象成员的构造函数
  • 基类的构造函数
  • 派生类对象成员的构造函数
  • 派生类的构造函数
  • 基类的析构函数
  • 基类中对象成员的析构函数

  即不会调用派生类的析构函数和派生类中对象成员的析构函数。

• 当基类析构函数是virtual的，才会按照常规情况的顺序全部调用。

基类析构函数应该定义为virtual

基类析构函数应该定义为虚函数，原因如下：

当基类指针指向派生类的时候，若基类析构函数不声明为虚函数，在析构时，只会调用基类而不会调用派生类的析构函数，从而导致内存泄露。

测试程序

测试程序如下：

#include <iostream>

class Base_Member{
public:
    Base_Member(){
        std::cout << "      Base_Member Constructor" << std::endl;
    }
    ~Base_Member(){
        std::cout << "      Base_Member Destructor" << std::endl;
    }
};

class Derived_Member{
public:
    Derived_Member(){
        std::cout << "      Derived_Member Constructor" << std::endl;
    }
    ~Derived_Member(){
        std::cout << "      Derived_Member Destructor" << std::endl;
    }
};


class Base{
public:
    Base(){
        std::cout << "      Base Constructor" << std::endl;
    }
    ~Base(){
        std::cout << "      Base Destructor" << std::endl;
    }
private:
    Base_Member bm;
};

class Derived : public Base{
public:
    Derived(){
        std::cout << "      Derived Constructor" << std::endl;
    }
    ~Derived(){
        std::cout << "      Derived Destructor" << std::endl;
    }
private:
    Derived_Member dm;
};

int main(){
    //派生类指针指向派生类对象
    std::cout << "------派生类指针指向派生类对象------" << std::endl;
    Derived* pDerived = new Derived();
    delete pDerived;
    std::cout << std::endl;

    //派生类指针不可以指向基类对象

    //基类指针指向基类对象
    std::cout << "------基类指针指向基类对象------" << std::endl;
    Base* pBase1 = new Base();
    delete pBase1;
    std::cout << std::endl;

    //基类指针指向派生类对象
    std::cout << "------基类指针指向派生类对象------" << std::endl;
    Base* pBase2 = new Derived();
    delete pBase2;
    std::cout << std::endl;
}

程序测试结果

• Base类的析构函数非虚时，程序输出如下：
  
• 将Base类的析构函数加上virtual后，程序输出如下：