C++基礎之繼承-有解無憂

一、類的繼承與類的派生

繼承和派生是人們認識客觀世界的程序，在程式設計方法中，人們追求代碼復用（這是提高軟體開發效率的重要手段)，將繼承和派生用于程式設計方法中，從而有了面向物件程式設計的重要特點，C++對代碼復用有很強的支持，
“繼承”就是支持代碼復用的機制之一，
通過已有的類建立新類的程序，叫作類的派生，原來的類稱為基類，也稱為父類或一般類；新類稱為派生類，也稱為子類或特殊類，派生類派生自基類，或繼承于基類，也可以說基類派生了派生類，派生機制是C++語言及面向物件程式設計方法的重要特征之一，派生類可以再作為基類派生新的派生類，由此基類和派生類的集合稱作類繼承層次結構，

繼承：

使用基類派生新類時，除建構式和解構式外，基類的所有成員自動成為派生類的成員，包括基類的成員變數和成員函式，同時，派生類可以增加基類中沒有的成員，這同樣是指成員變數和成員函式，可以重新定義或修改基類中已有的成員，包括可以改變基類中成員的訪問權限，當然派生類需要定義自己的建構式和解構式，
使用基類成員是一個重用的程序，在基類之上進行調整，不論是添加新成員還是改造己有的，都是擴充的程序，

覆寫：

　　若派生類中定義了一個與基類中同名的成員，則會出現基類與派生類有同名成員的情況，這是允許的，同名的成員既可以是成員變數，也可以是成員函式，這種情況下，若在派生類的成員函式中訪問這個同名成員，或通過派生類物件訪問這個同名成員時，除非特別指明，訪問的就是派生類中的成員，這種情況叫“覆寫”，即派生類的成員覆寫基類的同名成員，覆寫也稱為重定義或是重寫，對于成員函式來說，派生類既繼承了基類的同名成員函式，又在派生類中重寫了這個成員函式，這稱為函式重定義，也稱為同名隱藏，“隱藏”的意思是指，使用派生類物件呼叫這個名字的成員函式時，呼叫的是派生類中定義的成員函式，即隱藏了基類中的成員函式，

派生類可以改變基類中成員的訪問權限
空類也可以作為基類，也就是說，空類可以派生子類：

class emptyClass{ }; //慷訓類
class subemptyClass : public emptyClass{ }; //派生類

類的大小

派生類物件中包含基類成員變數，而且基類成員變數的存盤位置位于派生類物件新增的成員變數之前，派生類物件占用的存盤空間大小，等于基類成員變數占用的存盤空間大小加上派生類物件自身成員變數占用的存盤空間大小，
物件占用的存盤空間包含物件中各成員變數占用的存盤空間，出于計算機內部處理效率的考慮，為變數分配記憶體時，會根據其對應的資料型別，在存盤空間內對變數的起始地址進行邊界對齊，可以使用sizeof( )函式計算物件占用的位元組數，
物件的大小與普通成員變數有關，與成員函式和類中的靜態成員變數無關，即普通成員函式、靜態成員函式、靜態成員變數、靜態常量成員變數等均對類物件的大小沒有影響，

二、繼承關系的特殊性

1、友元

如果基類有友元類或友元函式，則其派生類不會因繼承關系而也有此友元類或友元函式，如果基類是某類的友元，則這種友元關系是被繼承的，即被派生類繼承過來的成員函式，如果原來是某類的友元函式，那么它作為派生類的成員函式仍然是某類的友元函式，總之，基類的友元不一定是派生類的友元；基類的成員函式是某類的友元函式，則其作為派生類繼承的成員函式仍是某類的友元函式，

#include<iostream>
using namespace std;
class another; //前向參考宣告
//基類
class Base {
    private:
    　　float x;
    public:
    　　void print(const another &K);
};
//派生類
class Derived:public Base {
    private:
        float y;
};
 //其他類
class another{private:
    int aaa;
public:
    another(){
        aaa=100;
    }
friend void Base::print(const another &K);//基類的成員函式宣告為本類的友元
};
void Base::print(const another &K){
    cout<<"Base:"<<K.aaa<<endl; //可以訪問私有成員變數
}
int main(){
    Base a;
    Derived d;
    another ano; //aaa 初始化為100
    a.print(ano); //輸出為：Base：100
    d.print(ano); //輸出為：Base：100
    return 0;
}

2、靜態屬性

如果基類中的成員是靜態的，則在其派生類中，被繼承的成員也是靜態的，即其靜態屬性隨靜態成員被繼承，
如果基類的靜態成員是公有的或是保護的，則它們被其派生類繼承為派生類的靜態成員，訪問這些成員時，通常用“<類名>::<成員名>”的方式參考或呼叫，無論有多少個物件被創建，這些成員都只有一個拷貝，它為基類和派生類的所有物件所共享，

#include<iostream>
using namespace std;
// 基類
class Base {
    private:
        float x;
    public:
        static int staV;
    Base(){ 
        staV++;
    }
};
int Base::staV=0;
//派生類
class Derived: public Base {
    private:
        float y;
    public:
        Derived( ){ 
            staV++;
        }
};
int main(){
    Base a;
    cout<< "Base:" <<a.staV<<endl; //輸出1
    Derived d;
    cout<< "Derived:" << d.staV<<endl; //輸出3(創建子類物件會呼叫父類構造器，然后呼叫自身的構造器)
    return 0;
}

3、繼承之間的訪問關系

派生類和基類中都可以定義自己的成員變數和成員函式，派生類中的成員函式可以訪問基類中的公有成員變數，但不能直接訪問基類中的私有成員變數，也就是說，不能在派生類的函式中，使用“基類物件名.基類私有成員函式(實參)”，或是“基類物件名.基類私有成員變數”，或是“基類名::基類私有成員”的形式訪問基類中的私有成員，
在類的派生層次結構中，基類的成員和派生類新增的成員都具有類作用域，二者的作用范圍不同，是相互包含的兩個層，派生類在內層，基類在外層，如果派生類宣告了一個和基類某個成員同名的新成員，派生的新成員就隱藏了外層同名成員，直接使用成員名只能訪問到派生類的成員，如果派生類中宣告了與基類成員函式同名的新函式，即使函式的引數表不同，從基類繼承的同名函式的所有多載形式也都會被隱藏，如果要訪問被隱藏的成員，就需要使用基類名和作用域分辨符來限定，

#include<iostream>
using namespace std;
class CB{
    public:
        int a;
        CB(int x){
            a=x;
        }
        void showa(){
            cout<<"Class CB--a="<<a<<endl;
        }
};
class CD:public CB{
    public:
        int a; //與基類a同名
        //x用來初始化基類的成員變數a
        CD(int x,int y):CB(x) { 
            a=y; 
        }
        //與基類showa同名        
        void showa() {
            cout<<"Class CD--a="<<a<<endl; 
        }
        //訪問派生類a            
        void print2a(){ 
            cout<<"a=" << a<<endl; 
            //訪問基類a
            cout<<"CB::a="<<CB::a<<endl;
        }
};
int main(){
    CB CBobj(12);
    CBobj.showa();//Class CB--a=12
    CD CDobj(48,999);
    CDobj.showa(); //訪問派生類的showa ()  Class CD--a=999
    CDobj.CB::showa(); //訪問基類的showa ()  Class CB--a=48
    cout<<"CDobj.a="<<CDobj.a<<endl; // CDobj.a=999
    cout<<"CDobj.CB::a="<<CDobj.CB::a<<endl;//CDobj.CB::a=48
}

4、protected訪問范圍說明符

定義類時，類成員可以使用protected訪問范圍說明符進行修飾，從而成為“保護成員”，保護成員的訪問范圍比私有成員的訪問范圍大，能訪問私有成員的地方都能訪問保護成員，此外，基類中的保護成員可以在派生類的成員函式中被訪問，
在基類中，一般都將需要隱藏的成員說明為保護成員而非私有成員，將基類中成員變數的訪問方式修改為protected后，在派生類中可以直接訪問，

三、多重繼承

C++允許從多個類派生一個類，即一個派生類可以同時有多個基類，這稱為多重繼承，相應地，從一個基類派生一個派生類的情況，稱為單繼承或單重繼承
派生類繼承了基類名1、基類名2、……、基類名n的所有成員變數和成員函式，各基類名前面的繼承方式說明符用于限制派生類中的成員對該基類名中成員的訪問權限，其規則與單繼承情況一樣，
多重繼承情況下如果多個基類間成員重名時，按如下方式進行處理：對派生類而言，不加類名限定時默認訪問的是派生類的成員；而要訪問基類重名成員時，要通過類名加以限定，

#include<iostream>
using namespace std;
class CB1{
    public:
        int a; 
        CB1 (int x){ a=x; }
        void showa(){ cout<<"ClassCB1==>a="<<a<<endl; }
};
class CB2{
    public:
        int a; 
        CB2 (int x){ a=x; }
        void showa(){ cout<<"ClassCB1==>a="<<a<<endl; }
};
//多重繼承，兩個基類
class CD:public CB1,public CB2 {
public:
    int a; //與兩個基類成員變數a重名
    CD(int x,int y,int z):CB1(x) ,CB2(y){ a=z; }
    //與兩個基類成員函式showa（）重名
    void showa() { 
        cout<<"Class CD==>a="<<a<<endl; 
    }
    void print3a(){ 
        cout<<"a="<<a<<endl;
        cout<<"CB1::a="<<CB1::a<<endl;
        cout<<"CB2::a="<<CB2::a<<endl;
    }
};
int main(){
    CB1 CB1obj(11);
    CB1obj.showa();//ClassCB1==>a=11
    CD CDobj(101,202,909);
    CDobj.showa(); //呼叫派生類的showa（）  //Class CD==>a=909
    CDobj.CB1::showa(); //呼叫基類的showa（） //ClassCB1==>a=101
    cout<<"CDobj.a="<<CDobj.a<<endl;//訪問派生類成員a  //CDobj.a=909
    cout<<"CDobj.CB2::a="<<CDobj.CB2::a<<endl; //CDobj.CB2::a=202
}

2、多重繼承的二義性

? 如果派生類中新增了同名成員，則派生類成員將隱藏所有基類的同名成員，使用“派生類物件名.成員名”或“派生類物件指標->成員名”的方式可以唯一標識和訪問派生類新增成員，這種情況下，不會產生二義性，
? 如果派生類中沒有新增同名成員，當滿足訪問權限時，使用“派生類物件名.成員名”或“派生類物件指標->成員名”方式時，系統無法判斷到底是呼叫哪個基類的成員，從而產生二義性，為了避免二義性，必須通過基類名和作用域分辨符來標識成員，
? 當要訪問派生類物件中的某個變數時，添加“基類::”作為前綴，指明需要訪問從哪個基類繼承來的，從而可以排除二義性，

3、繼承權限控制

設計繼承類時，需要使用繼承方式說明符指明派生類的繼承方式，繼承方式說明符可以是public(公有繼承）、private(私有繼承）或protected(保護繼承）

四、型別兼容

?型別兼容規則是指在需要基類物件的任何地方，都可以使用公有派生類的物件來替代，也稱為賦值兼容規則，在公有派生的情況下，有以下3條型別兼容規則，

1)派生類的物件可以賦值給基類物件，
2)派生類物件可以用來初始化基類參考，
3)派生類物件的地址可以賦值給基類指標，即派生類的指標可以賦值給基類的指標，

?上述3條規則反過來是不成立的，例如，不能把基類物件賦值給派生類物件，在進行替代之后，派生類物件就可以作為基類的物件使用了，但只能使用從基類繼承的成員，

?如果類B為基類，類D為類B的公有派生類，則類D中包含了基類B中除建構式、解構式之外的所有成員，這時，根據型別兼容規則，在基類B的物件可以出現的任何地方，都可以用派生類D的物件來替代，假設有以下的宣告：

class B{…}
class D : public B{…}
B b1, *pb1;
D d1;

?這時，派生類物件可以隱含轉換為基類物件，即用派生類物件中從基類繼承來的成員變數的值，逐個為基類物件的成員變數的值進行賦值，b1=d1;
?派生類的物件也可以用來初始化基類物件的參考，即:B &rb=d1;
?派生類物件的地址可以隱含轉換為指向基類的指標，即派生類物件的地址賦給基類指標：pb1=&d1;
?由于型別兼容規則的引入，對于基類及其公有派生類的物件，可以使用相同的函式統一進行處理，因為當函式的形參為基類的物件（或參考、指標）時，實參可以是派生類的物件(或指標)，從而沒有必要為每一個類設計單獨的模塊，大大提高了程式的效率，

五、私有繼承

六、保護繼承

　　保護繼承中，基類的公有成員和保護成員都以保護成員的身份出現在派生類中，而基類的私有成員不可以直接訪問，這樣，派生類的其他成員可以直接訪問從基類繼承來的公有和保護成員，但在類外通過派生類的物件無法直接訪問它們，

class A{};
class B:private A{};//私有繼承
class C:protected A{};//保護繼承

七、派生類的建構式和解構式

派生類并不繼承基類的建構式，所以需要在派生類的建構式中呼叫基類的建構式，以完成對從基類繼承的成員變數的初始化作業，具體來說，派生類物件在創建時，除了要呼叫自身的建構式進行初始化外，還要呼叫基類的建構式初始化其包含的基類成員變數，
在執行一個派生類的建構式之前，總是先執行基類的建構式，派生類物件消亡時，先執行派生類的解構式，再執行基類的解構式，

定義派生類建構式的一般格式如下：
派生類名::派生類名(引數表)：基類名1(基類1 初始化引數表),…,基類名m(基類m初始化引數表),成員物件名1(成員物件1 初始化引數表),…,成員物件名n(成員物件n 初始化引數表）{
    類建構式函式體 //其他初始化操作
}

派生類建構式執行的一般次序如下：

1)呼叫基類建構式，呼叫順序按照它們被繼承時宣告的順序（從左向右），
2)對派生類新增的成員變數初始化，呼叫順序按照它們在類中宣告的順序，
3)執行派生類的建構式體中的內容，
建構式初始化串列中基類名、物件名之間的次序無關緊要，它們各自出現的順序可以是任意的，無論它們的順序怎樣安排，基類建構式的呼叫和各個成員變數的初始化順序都是確定的，

#include<iostream>
using namespace std;
//基類
class BaseClass {
    protected:
        int v1,v2;
    public:
    BaseClass();
    BaseClass(int,int);
    ~BaseClass();
};
BaseClass::BaseClass(){ 
    cout<<"BaseClass 無參建構式"<<endl;
}
BaseClass::BaseClass(int m,int n){ 
    v1=m;
    v2=n;
    cout<<"BaseClass 2個引數建構式"<<endl;
}
BaseClass::~BaseClass(){ 
    cout<<"BaseClass解構式"<<endl; 
}
//公有繼承的派生類
class DerivedClass:public BaseClass { 
    int v3;
    public:
        DerivedClass();
        DerivedClass(int);
        DerivedClass(int,int,int);
        ~DerivedClass();
};
DerivedClass::DerivedClass(){
    cout<<"DerivedClass無參建構式"<<endl;
}
DerivedClass::DerivedClass(int k):v3(k){
    cout<<"DerivedClass 帶1個引數建構式"<<endl;
}
DerivedClass::DerivedClass(int m,int n,int k):BaseClass(m,n),v3(k){
    cout<<"DerivedClass 帶3個引數建構式"<<endl;
}
DerivedClass::~DerivedClass(){
    cout<<"DerivedClass解構式"<<endl;
}
int main(){
    cout<<"無參物件的創建"<<endl;
    BaseClass baseCla; //基類物件
    DerivedClass derivedCla; //派生類物件
    return 0;
}
無參物件的創建
BaseClass 無參建構式
BaseClass 無參建構式
DerivedClass無參建構式
DerivedClass解構式
BaseClass解構式
BaseClass解構式

八、復制建構式

對于一個類，如果程式中沒有定義復制建構式，則編譯器會自動生成一個隱含的復制建構式，這個隱含的復制建構式會自動呼叫基類的復制建構式，對派生類新增的成員物件執行復制，
如果要為派生類撰寫復制建構式，一般也需要為基類相應的復制建構式傳遞引數，但并不是必須的，

#include<iostream>
using namespace std;
class CBase{
public:
    CBase(){}
    CBase(CBase & c){
        cout<<"CBase::復制建構式"<<endl;
    }
    CBase & operator=(const CBase &b){
        cout<<"CBase::operator="<<endl;
        return *this;
    }
};
class CDerived:public CBase{
    public:
        CDerived(){
            cout<<"CDerived::復制建構式"<<endl;
        }
};
int main(){
    CDerived d1,d2;
    CDerived d3(d1);
    //d3初始化程序中會呼叫類CBase的復制建構式
    d2=d1; //會呼叫類CBase多載的"="運算子
    return 0;
}

九、派生類的建構式和解構式

派生類并不繼承基類的建構式，所以需要在派生類的建構式中呼叫基類的建構式，以完成對從基類繼承的成員變數的初始化作業，具體來說，派生類物件在創建時，除了要呼叫自身的建構式進行初始化外，還要呼叫基類的建構式初始化其包含的基類成員變數，
在執行一個派生類的建構式之前，總是先執行基類的建構式，派生類物件消亡時，先執行派生類的解構式，再執行基類的解構式，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/13742.html

標籤：C++

上一篇：MySQL資料庫管理陳述句用法（增、刪、改、查、授權……）

下一篇：稀疏矩陣類