c++中的類（class）-----筆記（類繼承）

1，派生類繼承了基類的所有成員函數和數據成員（構造函數、析構函數和操作符重載函數外）。

2，當不指明繼承方式時，默認為私有繼承。

3，基類的私有成員僅在基類中可見，在派生類中是不可見的。基類的私有成員可以由派生類繼承，但在派生類中不可見。盡管在派生類中不能直接訪問基類的私有成員，但可以通過間接的方式進行訪問（設置公有成員訪問函數）。

4，改變訪問限制：通過使用 using 聲明可以改變成員在派生類中的訪問限制。

class BC {
    public:
        void set_x(float a) { x = a;}
    private:
        float x;
}; 

class DC : public BC { 
    public:
        void set_y(float b) { y = b;}
    private:
        using BC::set_x;  // 只寫函數名 
        float y;
};

5，名字隱藏：如果派生類添加了一個數據成員，而該成員與基類中的某個數據成員同名，新的數據成員就隱藏了繼承而來的同名成員，同理，如果派生類添加了與基類的某個成員函數同名的函數，則該函數就隱藏了基類中的同名函數。

class BC {
    public:
        void h(float);
}; 

class DC : public BC {
    public:
        void h(char []);
};

int main() {
    DC d1;
    d1.h("Boffo!");  // DC::h,not BC::h
    //d1.h(707.7);  //  *****ERROR:DC:h hides BC::h
    d1.BC::h(707.7);  // OK: invokes BC::h
    
    return 0;
}  

6，保護成員：在沒有繼承的情況下，保護成員和私有成員類似（類的對象不能直接訪問保護成員）。保護成員在派生類中是可見的，僅在類層次結構中可見。一般避免將數據成員設計成保護類型，設計一個用來進行存取訪問的保護成員函數，通常將這種類型的成員函數稱為訪問函數。

7，派生類不能訪問一個基類對象的保護成員，這是因為基類對象屬於基類，不屬於派生類。

class BC {
    protected:
        int get_w() const;
        //...
};

class DC : public BC {
    void get_val() const { return get_w();}
    void base_w( const BC& b) const { cout<<b.get_w()<<endl; }  // ERROR
};

8，繼承機制下的構造函數：當創建一個派生類對象時，基類的構造函數被自動調用，用來對派生類對象中的基類部分進行初始化，並完成其它一些事務。如果派生類定義了自己的構造函數，則由該構造函數負責對象中“派生類添加部分”的初始化工作。

9，有時候基類的構造函數的功能對派生類而言已經足夠，這時候派生類不必自行設計構造函數，否則派生類必須定義自己的構造函數。可以在派生類的構造函數中調用其基類的構造函數（前提是基類擁有構造函數）。

10，在一個層次很深的類層次結構中，創建一個派生類對象將導致派生鏈中的所有類的構造函數被逐一調用，這是一個多米諾骨牌效應。構造函數的函數體將按照自頂向下（依照繼承層次）的次序依次執行。

class Animal {
    public:
        Animal() { species = "Animal";}
        Animal( const char* s) { species = s;}
    private:
        string species;
}; 

class Primate : public Animal {
    public:
        Primate() : Animal("primate") { }
        Primate(int n) : Animal("primate") { heart_cham = n;}
    private:
        int heart_cham;
};

class Human : public Primate {
    public:
        Human() : Primate() { }
        Human(int c) : Primate(c) { }
};

11，派生類構造函數的規則：如果基類擁有構造函數但沒有默認構造函數，那么派生類的構造函數必須顯式地調用基類的某個構造函數。一般建議為每個基類都設計一個默認構造函數。

class BC {
    public:
        BC(int a) { x = a;y = 999;}
        BC(int a,int b) { x = a;y = b;}
    private:
        int x;
        int y;
};

class DC : public BC {
    public:
        DC(int n) { z = n;}  // ERROR: DC(int) must explicitly invoke a BC constructor
    private:
        int z;
};

總結：（a）若 DC 有構造函數而 BC 沒有，當創建 DC 類的對象時，DC 的相應構造函數被自動調用。

　　　（b）若 DC 沒有構造函數而 BC 有，則 BC 必須擁有默認構造函數，只有這樣，當創建 DC 類的對象時，才會自動執行BC 的默認構造函數。

　　　（c）若 DC 有構造函數，而且 BC 有默認構造函數，則創建 DC 類的對象時，BC 的默認構造函數會自動執行，除非當前被調用的派生類構造函數在其初始化段中顯式地調用了 BC 的非默認構造函數。

　　　（d）若 DC 和 BC 都有構造函數，但 BC 沒有默認構造函數，則 DC 的每個默認構造函數必須在其初始化段中顯式地調用 BC 的某個構造函數。只有這樣，當創建 DC 類的對象時，BC 的構造函數才能獲得執行機會。

12，繼承機制下的析構函數：析構函數按照派生類到基類的次序執行，因此，析構函數的執行次序和構造函數的執行次序時相反的。由於每個類至多只有一個析構函數，因此對析構函數的調用不會產生二義性，這樣在析構函數中不必顯式地調用其他析構函數。

class BC {
    public:
        BC() { cout<<"BC's constructor"<<endl;}
        ~BC() { cout<<"BC's destructor"<<endl;}
};

class DC : public BC {
    public:
        DC() { cout<<"DC's constructor"<<endl;}
        ~DC() { cout<<"DC's destructor"<<endl;}
};


int main() {
    DC d;
    
    return 0;
} 

// out
//BC's constructor
//DC's constructor
//DC's destructor
//BC's destructor

13，多繼承：在多繼承中，一個派生類可以有多個基類，構造的層次結構是圖。派生類是其所有基類的組合體。

14，繼承和訪問規則：使用多繼承機制，將增加命名沖突出現的可能性，表現形式有兩種：（a）派生類和某個基類之間發生命名沖突；（b）基類與基類之間發生命名沖突。（在單繼承中稱為名字隱藏），通過使用域解析符來解決。

class BC1 {
    private:
        int x;
    public:
        void set_x(int a) { x = a;}
};

class BC2 {
    private:
        int x;
    public:
        void set_x(int a) { x = a;}
};

class DC : public BC1,public BC2 {
    private:
        int x;
    public:
        void set_x(int a) { x = a;}
};

int main() {
    DC d;
    d.set_x(999); // local set_x
    d.BC1::set_x(111);
    d.BC2::set_x(222);
    return 0;
} 

15，虛基類：解決派生類從同一個間接基類繼承了多次（獲取了相同的數據成員 x 多次），用虛基類來解決。將 DC1 和 DC2 說明為 z 的虛基類，就是要求 DC1 和 DC2 僅將同名數據成員的一份拷貝發放到 z 當中，而不管 DC1 和 DC2 從共同的祖先獲得了多少個同名的數據成員。

class BC {
    int x;
    //...
};

class DC1 : virtual public BC {  // 改 DC1 為虛基類 
    //...
};

class DC2 : virtual public BC {  // 改 DC2 為虛基類 
    //...
};

class z : public DC1,public DC2 {
    //...
};

16，保護繼承：（a）基類的所有成員在派生類中是保護成員。

　　　　　　　 （b）基類中的保護成員在派生類中是保護成員。

　　　　　　　 （c） 基類中的所有私有成員僅在基類中可見。

17，私有繼承：

　　　　　　　 （a）基類的所有成員在派生類中是私有的。

　　　　　　　 （b）基類的保護成員在派生類中是私有的。

　　　　　　　 （c） 基類的私有成員僅在基類中可見。