Constructor, class member, destructor call order

1. Constructors 、 Members of the class 、 Destructor call order

C++ The calling order of the constructor is ：

Members of the base class -> The constructor body of the base class -> Members of derived classes -> Constructor body of derived class

C++ The order in which destructors are called is ：

Destructors of derived classes -> Member destructors of derived classes -> The destructor of the base class -> Member destructor of base class

• Example 1： Constructors 、 Class member call order
• Example 2： Base class 、 Derived class constructors （ Destructor ） Call to order
• Example 3： comprehensive ： Base class 、 Derived class constructors （ Destructor ）、 Class member call order
• Example 4： comprehensive ： Base class 、 Derived class virtual destructor （virtual Virtual functions ） Call to order

1.1. Example 1： Constructors 、 Class member call order

#include <iostream>
 
class ParentMember
{
public:
    ParentMember()
    {
        std::cout<<"ParentMember Construct"<<std::endl;
    }
 
    ~ParentMember()
    {
        std::cout<<"ParentMember Destruct"<<std::endl;
    }
};
 

class Parent
{
public:
    Parent()
    {
        std::cout<<"Parent Construct"<<std::endl;
    }
 
    ~Parent()
    {
        std::cout<<"Parent Destruct"<<std::endl;
    }
private:
    ParentMember parentMember;
};
 
 
int main()
{
    cout<<"Construct The process : "<<endl;
    Parent *p = new Parent;
    
    cout<<""<<endl;

    cout<<"Destruct The process : "<<endl;
    delete p;

}

Running results ：

   Construct The process : 
   ParentMember Construct
   Parent Construct

   Destruct The process : 
   Parent Destruct
   ParentMember Destruct

It's not hard to see from the running results ：
1、 In the process of construction , The order of execution is ： Members of the class -> Class constructor body .
If breakpoint debugging , Will find , First run to the constructor '{' It's about , You will turn around and call the member variable first .

2、 In the course of deconstruction , The order of execution is ： Destructor of class -> Class member destructs

1.2. Example 2： Base class 、 Derived class constructors （ Destructor ） Call to order

Base class 、 The order in which derived classes are constructed

• The base (base) -> The derived (derived); That is, first construct the base class , Construct derived classes again ;
• because Base class Is independent of derived classes , That is, objects in derived classes will not be called , So it should be generated first ;
• If the derived class is generated before the base class , Because the base class resource cannot be called , Generation may fail ;

Base class 、 The order in which derived classes are destructed

• The derived (derived) -> The base (base); That is, release the derived class first , Release the base class ;
• because Derived class You need to release the called base class resources first , Therefore, priority should be given to release ;
• If the base class is destructed first , Some resources may be occupied by derived classes , May cause destruct failure ;

#include <iostream>


class Parent
{
public:
    Parent()
    {
         std::cout<<"Parent Construct"<< std::endl;
    }
 
    ~Parent()
    {
         std::cout<<"Parent Destruct"<< std::endl;
    }    
};

class Child: public Parent
{
public:
    Child()
    {
         std::cout<<"Child Construct"<< std::endl;
    }
    
    ~Child()
    {
         std::cout<<"Child Destruct"<< std::endl;
    }

};
 
  
int main()
{
     std::cout<<"Construct The process : "<< std::endl;
     Parent *p = new Child;
    
     std::cout<<" "<< std::endl;
     
     std::cout<<"Destruct The process : "<< std::endl;
     delete p;

}

Running results ：

   Construct The process : 
   Parent Construct
   Child Construct
   
   Destruct The process :
   Parent Destruct   
      

It's not hard to see from the running results ：
1、 In the process of construction , The order of execution is ： First base class , The latter subclass , namely ： The constructor body of the base class -> The constructor body of a subclass
If breakpoint debugging , Will find , First run to the subclass constructor '{' It's about , You will call the base class member variable first .

2、 In the course of deconstruction , The order of execution is ： How can we just base classes ？
The order of execution should have been ： Antecedent subclass , Post base class , That is, the destructor of the subclass -> The destructor of the base class . But it is not difficult for us to find out the actual operation effect , Release the pointer at the end p The object pointed to , Only part of the base class is released , No part of the derived class is released . This is because , The pointer p When declared, it is a pointer to the base class , The destructor of the base class is not an imaginary function , So calling that destructor is determined at compile time . If you want to perform the correct destruct order , The destructor of the base class needs to be defined as virtual, In this way, the destructor of the derived class is automatically virtual Of course. , Release the pointer at the end p when , according to RTTI, perform p The destructor of the real object .

class Parent
{
public:
    Parent()
    {
         std::cout<<"Parent Construct"<< std::endl;
    }
 
    virtual ~Parent()   // increase virtual
    {
         std::cout<<"Parent Destruct"<< std::endl;
    }    
};

Running results after modification ：

   Construct The process : 
   Parent Construct
   Child Construct
   
   Destruct The process :
   Child Destruct
   Parent Destruct   
      

1.3. Example 3： comprehensive ： Base class 、 Derived class constructors （ Destructor ）、 Class member call order

#include <iostream>

 
class ParentMember
{
public:
    ParentMember()
    {
        std::cout<<"ParentMember Construct"<< std::endl;
    }
 
    ~ParentMember()
    {
         std::cout<<"ParentMember Destruct"<< std::endl;
    }
};
 

class Parent
{
public:
    Parent()
    {
         std::cout<<"Parent Construct"<< std::endl;
    }
 
    ~Parent()
    {
         std::cout<<"Parent Destruct"<< std::endl;
    }
    
private:
    ParentMember parentMember;
    
};

class ChildMember
{
public:
    ChildMember()
    {
         std::cout<<"ChildMember Construct"<< std::endl;
    }
 
    ~ChildMember()
    {
        // std::cout<<"ChildMember Destruct"<< std::endl;
    }
};

class Child: public Parent
{
public:
    Child()
    {
         std::cout<<"Child Construct"<< std::endl;
    }
    
    ~Child()
    {
         std::cout<<"Child Destruct"<< std::endl;
    }
private:
    ChildMember childMember;
};
 
  
int main()
{
     std::cout<<"Construct The process : "<< std::endl;
      and Parent *p = new Child;
    
     std::cout<<""<< std::endl;

     std::cout<<"Destruct The process : "<< std::endl;
     delete p;

}

Running results ：

   Construct The process : 
   ParentMember Construct
   Parent Construct
   ChildMember Construct
   Child Construct
   
   Destruct The process :
   Parent Destruct   
   ParentMember Destruct
      

It's not hard to see from the running results , In the process of construction , The order of execution is ：

• First base class , Post derivation ;
• Base class first member 、 Post constructor body ;
• Derived class first member 、 Post constructor body ;
• The overall call sequence is ： Members of the base class -> The constructor body of the base class -> Members of derived classes -> Constructor body of derived class ;
• If breakpoint debugging , Will find , First run to the subclass constructor '{' It's about , You will call the base class member variable first .

Destructor execution order did not execute as expected , See ： Example 2 The tail details . Revise the plan , See ： Example 4.

1.4. Example 4： comprehensive ： Base class 、 Derived class virtual destructor （virtual Virtual functions ） Call to order The optimized scheme

class Parent
{
public:
    Parent()
    {
         std::cout<<"Parent Construct"<< std::endl;
    }
 
    virtual ~Parent()   // increase virtual
    {
         std::cout<<"Parent Destruct"<< std::endl;
    }
    
private:
    ParentMember parentMember;
    
};

Running results ：

   Construct The process : 
   ParentMember Construct
   Parent Construct
   ChildMember Construct
   Child Construct
   
   Destruct The process :
   Child Destruct
   //ChildMember Destruct  // No output ???
   Parent Destruct   
   ParentMember Destruct
      

It is not difficult to see the following rules ：

C++ The calling order of the constructor is ：

Members of the base class -> The constructor body of the base class -> Members of derived classes -> Constructor body of derived class

C++ The order in which destructors are called is ：

Destructors of derived classes -> Member destructors of derived classes -> The destructor of the base class -> Member destructor of base class