C++繼承中的構造和析構

1，構造：對象在創建的后所要做的一系列初始化的工作；

      析構：對象在摧毀之前所要做的一系列清理工作；

 

2，思考：

    1，子類中如何初始化父類成員？

       1，對於繼承而言，子類可以獲得父類的代碼，可以獲得父類中的成員變量，成員變量從父類中傳遞到子類，那么子類對象在創建的時候如何初始化從父類中繼承的成員變量呢？

    2，父類構造函數和子類構造函數有有什么關系？  

   

3，子類對象的構造：

    1，子類中可以定義構造函數；

       　　1，子類中定義的新的構造函數，對於子類對象創建的時候必須完成一系列的初始化工作，這些初始化工作包括初始化繼承而來的成員，第一種方式直接對他們進行賦值或者直接將他們寫到初始化列表中去進行初始化，第二種方式更直接，在子類構造的時候我們調用父類構造函數進行初始化；

       　　2，這就是子類構造函數可以用來初始化父類成員的兩種方式；

    2，子類構造函數：

       　　1，必須對繼承而來的成員進行初始化；

           　　1，直接通過初始化列表或者賦值的方式進行初始化；

              　　　　1，有可能從父類中繼承了 private 成員，因此直接來進行賦值或初始化根本就是行不通的，因此這個時候只能通過父類的構造函數來進行初始化的工作；

           　　2，調用父類構造函數進行初始化；

    3，父類構造函數在子類中的調用方式；

       　　1，默認調用：

           　　1，子類對象在創建的時候會自動的調用父類的構造函數；

           　　2，適用於無參構造函數和使用默認參數的構造函數；

              　　　　1，對於需要參數的構造函數來說，默認的調用方式是行不通的，必須顯示調用；     

       　　2，顯示調用：

           　　1，通過初始化列表進行調用；

              　　　　1，只能在初始化列表中調用；

           　　2，適用於所有父類構造函數；

       3，父類構造函數的調用：

           1，代碼示例：

class Child : public Parent
{
Public:
    Child() /* 隱式調用 */
    {
         Cout << “Child()” << endl;
    }

    Child(string s)  : Parent(“Parameter to Parent”)  /* 顯示調用 */ 
    {
         Cout << “Child() : “ << s << endl;
    }
};

 

4，子類的構造初探編程實驗：

#include <iostream>
#include <string>

using namespace std;

class Parent 
{
public:
    Parent()
    {
        cout << "Parent()" << endl;
    }
    
    Parent(string s)
    {
        cout << "Parent(string s) : " << s << endl;
    }
};

class Child : public Parent
{
public:
    Child()  // 隱式調用父類構造函數中的無參或默認初始值構造函數
    {
        cout << "Child()" << endl;
    }
    
    Child(string s)  // 隱式調用父類構造函數中的無參或默認初始值構造函數；
    {
        cout << "Child(string s) : " << s << endl;
    }
    
    Child(string s): Parent(s)  // 顯示調用父類構造函數；
    {
        cout << "Child(string s) : " << s << endl;
    }
};

int main()
{       
    Child c;  // 調用父類無參構造函數，然后調用子類無參構造函數；
    Child cc("cc");  // 調用父類有參構造函數，然后調用子類構造函數；
    
    return 0;
}

    1，子類和父類的構造函數的調用都嚴格按照重載規則調用；

   

5，子類對象的構造：

    1，構造規則：

       1，子類對象在創建時會首先調用父類的構造函數（要以子類構造函數調用為依據）；

       2，先執行父類構造函數再執行子類構造函數；

       3，父類構造函數可以被隱式調用或者顯示調用；

    2，對象創建時構造函數的調用順序：

       1，調用父類的構造函數；

       2，調用成員變量的構造函數；

       3，調用類自身的構造函數；

       4，口訣：

           1，先父母（調到最上的父母為止），后客人（按照成員變量申明的順序），再自己；

           2，非常實用；

    3，子類構造深度解析編程實驗：

#include <iostream>
#include <string>

using namespace std;

class Object
{
public:
    Object(string s)
    {
        cout << "Object(string s) : " << s << endl;
    }
};

class Parent : public Object
{
public:
    Parent() : Object("Default")  // 必須顯示調用
    {
        cout << "Parent()" << endl;
    }
    
    Parent(string s) : Object(s)  // 必須顯示調用
    {
        cout << "Parent(string s) : " << s << endl;
    }
};

class Child : public Parent
{
    Object mO1;  // 組合關系，默認構造函數和有參數構造函數，這里必須顯示調用
    Object mO2;
    
public:
    Child() : mO1("Default 1"), mO2("Default 2")
    {
        cout << "Child()" << endl;
    }
    
    Child(string s) : Parent(s), mO1(s + " 1"), mO2(s + " 2")  // 父母和成員客人的區別在於父母構造函數直接調用，客人構造函數通過對象調用；
    {
        cout << "Child(string s) : " << s << endl;
    }
};

int main()
{       
    Child cc("cc");
    
    // cc output:
    // Object(string s) : cc  父母
    // Parent(string s) : cc  父母
    // Object(string s) : cc 1  客人
    // Object(string s) : cc 2  客人
    // Child(string s) :  cc  自己
    
    return 0;
}

   

6，子類對象的析構：

    1，析構函數的調用順序與構造函數相反：

       1，執行自身的析構函數；

       2，執行成員變量的析構函數；

       3，執行父類的析構函數；

    2，對象的析構編程實驗：

#include <iostream>
#include <string>

using namespace std;

class Object
{
    string ms;  // 為了驗證析構函數的輸出，定義了這個成員變量來傳遞值，因為構造函數可以由外界傳入值，但是析構函數沒有參數，是不可以由完結傳入值的；
    
public:
    Object(string s)
    {
        cout << "Object(string s) : " << s << endl;
        ms = s;
    }
    
    ~Object()
    {
        cout << "~Object() : " << ms << endl;
    }
};

class Parent : public Object
{
    string ms;
    
public:
    Parent() : Object("Default")
    {
        cout << "Parent()" << endl;
        ms = "Default";
    }
    
    Parent(string s) : Object(s)
    {
        cout << "Parent(string s) : " << s << endl;
        ms = s;
    }
    
    ~Parent()
    {
        cout << "~Parent() : " << ms << endl;
    }
};

class Child : public Parent
{
    Object mO1;
    Object mO2;
    string ms;
    
public:
    Child() : mO1("Default 1"), mO2("Default 2")
    {
        cout << "Child()" << endl;
        ms = "Default";
    }
    
    Child(string s) : Parent(s), mO1(s + " 1"), mO2(s + " 2")
    {
        cout << "Child(string s) : " << s << endl;
        ms = s;
    }
    
    ~Child()
    {
        cout << "~Child() " << ms << endl;
    }
};

int main()
{       
    Child cc("cc");
    
    cout << endl;
    
    return 0;
}

      

7，小結：

    1，子類對象在創建時需要調用父類構造函數進行初始化；

    2，先執行父類構造函數然后執行成員的析構函數；

    3，父類構造函數顯示調用需要在初始化列表中進行；

    4，子類對象在銷毀時需要調用父類析構函數進行清理；

    5，析構順序與構造順序對稱相反；

       1，先自己，后客人，再父母；