C++筆記 --- 類的繼承

 

目錄

繼承
單繼承
多繼承

 (本章節中例子都是用 VS2005 編譯調試的)

---

 

繼承

方式:

• private 　　　　基類的公有成員與保護成員成為派生類的私有成員
• public 　　  　　基類的成員訪問權限不變
• protected 　　  基類的公有成員與保護成員將成為派生類的保護成員

三種繼承方式的對比:

特征 　　　　　　公有繼承 　　　　　　　　保護繼承 　　　　　　　　　　私有繼承　　　　　　
公有成員繼成 　　派生類公有成員 　　　　　派生類保護成員　　　 　　　　派生類私有成員
私有成員繼成 　　只能通過基類接口訪問 　　只能通過基類接口訪問 　　　　只能通過基類接口訪問
保護成員繼成 　　派生類保護成員 　　　　　派生類保護成員 　　　　　　　派生類私有成員
能否隱式轉換 　　是 　　　　　　　　　　　是(但只能在此派生類中) 　　　否

在沒有虛函數的情況下,類指針調用函數是注意:

• 如果以一個基類指針指向派生類對象,那么經由該指針只能調用基類所定義的函數
• 如果你以一個派生類的指針指向一個基類對象,你必須先做明顯的強制轉換,但是這樣做很危險
• 如果基類和派生類都定義了相同名的成員函數,那么通過對象指針調用成員函數時候,調用的函數是由指針的原始類型而定,而不是看指針指向的對象的類型而定

虛函數表:

定義:

為了達到動態綁定(后期綁定)的目的,C++編譯器通過某個表格,在執行期"間接"調用實際上欲綁定的函數(注意"間接"字眼).這樣的表格稱為虛函數表(常被稱為vtable).每一個"內含虛函數的類",編譯器都會為它做一個虛函數表,表中的每一個元素都指向一個虛函數的地址.此外,編譯器當然會為這個類加上一項成員變量,是一個指向這個虛函數表的指針(常被稱為vptr),且每個由此派生出來的對象,都會有這個一個vptr.

介紹:

當我們通過這個對象調用虛函數時,事實上是通過vptr找到虛函數,再找出真實的地址,虛函數表用這種間接的的方式,虛函數表的內容是依據類中的虛函數聲明次序,意義填入函數表(以及所有其他可以繼承的成員),當我們在派生類中改寫虛函數時,虛函數表就受了影響:表中元素所指的函數地址將不再是基類的函數地址,而是派生類的地址

參考鏈接:　　[什么是虛函數] 　　[虛函數表解析]

例子:

三個繼承權限的區別:

class ex0
{
private:
    void showPrivate(){cout<<"this is private function!";}
public:
    void showPublic(){cout<<"this is public function!";}
protected:
    void showProtected(){cout<<"this is protected function!";}
};
class ex1:public ex0
{
public:
    void func()
    {
        showPrivate();
        //錯誤因為此函數訪問權限只有基類 ex0 自己有
        showPublic();
        showProtected();
    }
};
class ex2:protected ex0
{
public:
    void func()
    {
        showPrivate();
        //錯誤因為此函數訪問權限只有基類 ex0 自己有
        showPublic();
        //正確, 但是此函數由於 ex2 的保護繼承這個函數的訪問權限已經變成了 protected,
        //也就是說對於外部類來說已經不具備訪問這個函數的權限了
        showProtected();
    }
};
class ex3:private ex0
{
public:
    void func()
    {
        showPrivate();
        //錯誤因為此函數訪問權限只有基類 ex0 自己有
        showPublic();
        //正確, 但是此函數由於 ex3 的私有繼承這個函數的訪問權限已經變成了 private,
        //也就是說對於外部類和派生類來說已經不具備訪問這個函數的權限了
        showProtected();
        //正確, 但是此函數由於 ex3 的私有繼承這個函數的訪問權限已經變成了 private,
        //也就是說對於外部類和派生類來說已經不具備訪問這個函數的權限了
    }
};

有沒有虛函數的情況下,類指針調用函數的區別:

[此處例子鏈接] 

[返回目錄]

---

 

單繼承

聲明格式:

class 派生類名：繼承方式（若不具體指出默認為private） 基類名
{
　　　　…
};

特性:

繼承了基類所有屬性與行為,包括私有成員,但不允許派生類直接訪問基類私有成員

構造函數:

格式:　　 派生類構造函數名（形參表）：基類構造函數名（形參表）{…}

要點:

● 創建派生類對象時,程序首先創建基類對象,即基類對象應在進入派生類構造函數前被創建完成
 （即先調用基類構造函數,后調用派生類構造函數）
● 派生類構造函數應通過成員初始化表將基類信息傳遞給基類構造函數
● 派生類構造函數應初始化派生類新增的數據成員

析構函數:

特性:　　　　派生類對象過期時,程序將首先調用派生類析構函數,然后調用基類的

虛析構函數:

作用:　　和虛函數一樣類似,在用基類指針釋放派生類對象時候,為了能調用正確的析構函數.

注意:　　當一個類有虛函數功能,它經常作為一個基類使用,並且它的派生類經常使用new來分配,那么它最好也使用虛析構函數,因為這樣才能保證在釋放實例對象的時候調用正確的析構函數

注意:

• 構造函數的調用次序為 基類 -> 派生類
• 析構函數的調用次序為 派生類 -> 基類

例子:

構造函數和析構函數的調用順序:

#include <iostream>
#include <string>
using namespace std;

class A{
public:
    A(){cout<<"A::A()    ";}
    ~A(){cout<<"A::~A()"<<endl;}
};
class B:virtual public A{
public:
    B(){cout<<"B::B()    "<<endl;}
    ~B(){cout<<"B::~B()    ";}
};
void func()
{
    cout<<"this is class D:"<<endl;
    cout<<"the order of constructor:    ";
    B b;
    cout<<"the order of destructor:    ";
}

void main()
{
    func();
    system("pause");
}
/********************************
輸出結果:
this is class D:
the order of constructor:       A::A()    B::B()
the order of destructor:        B::~B()    A::~A()
請按任意鍵繼續. . .
********************************/

虛函數使用:

[此處為鏈接]

無虛析構函數:

class A{
public:
    A(){cout<<"A::A()    ";}
    ~A(){cout<<"A::~A()"<<endl;}
};
class B:public A{
public:
    B(){cout<<"B::B()    "<<endl;}
    ~B(){cout<<"B::~B()    ";}
};
void func()
{
    A* pb = new B();
    delete pb;
}
/******************************************
調用 func 函數的輸出結果:
A::A()    B::B()
A::~A()
******************************************/

有虛析構函數:

class A{
public:
    A(){cout<<"A::A()    ";}
    virtual ~A(){cout<<"A::~A()"<<endl;}
};
class B:public A{
public:
    B(){cout<<"B::B()    "<<endl;}
    ~B(){cout<<"B::~B()    ";}
};
void func()
{
    A* pb = new B();
    delete pb;
}
/*****************************************
調用 func 函數的輸出結果:
A::A()    B::B()
B::~B()    A::~A()
*****************************************/

基類構造函數的調用:

class A{
public:
    A(){cout<<"this is A::A()"<<endl;}
    A(int b){cout<<"this is A::A(int b):    the value of b is: "<<b<<endl;}
    A(double b){cout<<"this is A::A(double b)    the value of b is: "<<b<<endl;}
};
class B:public A{
public:
    B():A(){}  //調用基類 A 默認構造函數
    B(int b):A(b){} //調用基類 A 的 A::A(int b) 構造函數
    B(double b):A(b){} //調用基類 A 的 A::A(double b) 構造函數
};
void main()
{
    B b0,b1(5),b2(10.5);//產生三個實例,分別調用不同的基類構造函數
    system("pause");
}
/***********************************
調用 func 函數的輸出結果:
this is A::A()
this is A::A(int b):    the value of b is: 5
this is A::A(double b)    the value of b is: 10.5
***********************************/

 [返回目錄]

---

 

多繼承

聲明格式:

class 派生類名：繼承方式 基類名,繼承方式 基類名… {….};

構造函數:

• 形式:

派生類名：：派生類名（形參表）：基類名（形參表）,基類名（形參表）…{…}

• 特點:

處理同一層的基類構造函數的執行順序取決於定義派生類對各基類的排列順序,與定義派生類的構造函數時基類的排列順序無關

• 二定義性:

原因:

• 由於多層次的交叉派生類關系,造成一個派生類對象包含了基類成員的多個副體
• 多個基類中某個成員名相同

方法:

• 用虛基類來解決由於多層次的交叉派生類關系(原理：采用虛基類定義方式定義派生類,在創建派生類時,類層次結構中某個虛基類的成員只保留一個,即虛基類成員的一個副本被所有派生類共享)
• 用基類中定義成員的訪問修改方法來解決多個基類中某個成員名相同

虛基類:

聲明格式： 　　class 派生類名：virtual 繼承方式 基類名,… { … };

注意:

• virtual與繼承方式之間的次序無關且將基類作為虛基類,計算機為此完成一些額外計算量慎用
• 一個類可以在一個類族中用作虛基類,也可以用作非虛基類.
• 在派生類的對象中,同名的虛基類只產生一個虛基類子對象,而某個非虛基類產生各自的對象.
• 虛基類子對象是由最派生類的構造函數通過調用虛基類的構造函數進行初始化的.
• 最派生類是指在繼承結構中建立對象時所指定的類.
• 在派生類的構造函數的成員初始化列表中,必須列出對虛基類構造函數的調用,如果沒有列出,則表示使用該虛基類的缺省構造函數.
• 在虛基類直接或間接派生的派生類中的構造函數的成員初始化列表中,都要列出對虛基類構造函數的調用.但只有用於建立對象的最派生類的構造函數調用虛基類的構造函數,而該派生類的所有基類中列出的對虛基類構造函數的調用在執行中被忽略,從而保證對虛基類子對象只初始化一次.
• 在一個成員初始化列表中,同時出現對虛基類和非虛基類構造函數的調用時,基類的構造函數先於非虛基類的構造函數執行

有虛基類和無虛基類的區別:

• 有虛基類:

• 無虛基類:

例子:

沒有虛基類繼承:

#include <iostream>
#include <string>
using namespace std;

class A{
protected:
    int a;
public:
    A():a(0){}; //對成員變量 a 進行初始化
};
class B:public A{
public:
    void B_changeValue(int b) //在派生類 B 中修改基類 A 的成員變量 a 並輸出其前后的值
    {
        cout<<"in the class B"<<endl;
        cout<<"the original value of a is:   "<<a<<endl;
        a = b;
        cout<<"the value after change is:   "<<a<<endl<<endl;
    }
};
class C:public A{
public:
    void C_changeValue(int c) //在派生類 C 中修改基類 A 的成員變量 a 並輸出其前后的值
    {
        cout<<"in the class C"<<endl;
        cout<<"the original value of a is:   "<<a<<endl;
        a = c;
        cout<<"the value after change is:   "<<a<<endl<<endl;
    }
};
class D:public B,public C{

};

void main()
{
    D d;
    d.B_changeValue(10);
    d.C_changeValue(20);
    d.B_changeValue(11);
    d.C_changeValue(21);
    system("pause");
}

 輸出結果:

由此可以看出,其實派生類 D 從基類 B 與基類 C 中繼承了兩份 A 的數據變量備份

有虛基類的繼承:

#include <iostream>
#include <string>
using namespace std;

class A{
protected:
    int a;
public:
    A():a(0){}; //初始化成員變量 a
};
class B:virtual public A{
public:
    void B_changeValue(int b) // 在派生 B 中修改基類 A 的成員變量 a 並輸出其修改前后的值
    {
        cout<<"in the class B"<<endl;
        cout<<"the original value of a is:   "<<a<<endl;
        a = b;
        cout<<"the value after change is:   "<<a<<endl<<endl;
    }
};
class C:virtual public A{
public:
    void C_changeValue(int c) // 在派生 C 中修改基類 A 的成員變量 a 並輸出其修改前后的值
    {
        cout<<"in the class C"<<endl;
        cout<<"the original value of a is:   "<<a<<endl;
        a = c;
        cout<<"the value after change is:   "<<a<<endl<<endl;
    }
};
class D:public B,public C{

};

void main()
{
    D d;
    d.B_changeValue(10);
    d.C_changeValue(20);
    d.B_changeValue(11);
    d.C_changeValue(21);
    system("pause");
}

  輸出結果:

由此可以看出,這次派生類 D 從基類 B 與基類 C 中繼承了只有一份 A 的數據變量備份

構造函數與析構函數的順序:

#include <iostream>
#include <string>
using namespace std;

class A{
public:
    A(){cout<<"A::A()    ";}
    ~A(){cout<<"A::~A()"<<endl;}
};
class B:virtual public A{
public:
    B(){cout<<"B::B()    ";}
    ~B(){cout<<"B::~B()    ";}
};
class C:virtual public A{
public:
    C(){cout<<"C::C()    ";}
    ~C(){cout<<"C::~C()    ";}
};
class D:public B,public C{
public:
    D():C(),B(){cout<<"D::D()"<<endl;}
    ~D(){cout<<"D::~D()    ";}
};
class E:public C,public B
{
public:
    E():C(),B(){cout<<"E::E()"<<endl;}
    ~E(){cout<<"E::~E()    ";}
};
void funcD()
{
    cout<<"this is class D:"<<endl;
    cout<<"the order of constructor:    ";
    D d;
    cout<<"the order of destructor:    ";
}
void funcE()
{
    cout<<"this is class E:"<<endl;
    cout<<"the order of constructor:    ";
    E e;
    cout<<"the order of destructor:    ";
}
void main()
{
    funcD();
    cout<<endl;
    funcE();
    cout<<endl;
    system("pause");
}

 輸出結構:

由此可以看出,構造函數的順序與繼承順序有關,而不是基類構造函數的調用有關

基類構造函數調用:

#include <iostream>
#include <string>
using namespace std;

class A{
public:
    A(){cout<<"this is A::A()"<<endl;}
    A(int b){cout<<"this is A::A(int b):    the value of b is: "<<b<<endl;}
    A(double b){cout<<"this is A::A(double b)    the value of b is: "<<b<<endl;}
};
class B
{
public:
    B(){cout<<"this is B::B()"<<endl;}
    B(int b){cout<<"this is B::B(int b):    the value of b is: "<<b<<endl;}
    B(double b){cout<<"this is B::B(double b)    the value of b is: "<<b<<endl;}
};
class C:public A,public B{
public:
    C():A(),B(){cout<<endl;}
    C(int b,double c):A(b),B(c){cout<<endl;}
    C(double b,int c):A(b),B(c){cout<<endl;}
};
void main()
{
    C c0,c1(5,15.123),c2(10.5,1235);
    system("pause");
}

輸出結果:

[返回目錄]