C++ 面向對象的三個特色--繼承與封裝（二）

順着上一篇的內容，咱們繼續來了解繼承的基本知識。

• 派生類的構造函數和析構函數

派生類繼承了基類的成員，可是不能繼承基類的構造函數和析構函數，首先，咱們瞭解構造函數和析構函數的執行順序是當咱們建立一個派生類的對象是，先執行的是基類的構造函數，而後是派生類的構造函數。析構函數則正好相反，先執行派生類的析構函數，再執行基類的析構函數。

• 派生類構造函數和析構函數的構造規則

當基類的構造函數沒有參數的時，或者沒有顯示的定義構造函數時，派生類能夠不向基類傳遞參數，甚至能夠不定義構造函數。可是當基類帶有含參數的構造函數的時候，派生類必須定義構造函數，以提供把參數傳遞給基類構造函數的途徑。

派生類構造函數的定義格式：

派生類名(參數總表) : 基類名(參數表)

其中基類的構造函數參數一般來源於派生類構造函數的參數總表，也能夠設置爲常數值。

例：

base:

base(int n)

derived:

derived(int n) : base(n)

或derived() : base(1)

還需注意的幾點：

1）.若是派生類的基類也是一個派生類，每一個派生類只需負責他的直接基類的構造，依次上溯。

2）.由於析構函數是不帶參數的，在派生類中是否要定義析構函數與它所屬的基類無關，它們是各自獨立的。

3）.派生類中含有內嵌對象成員時，構造函數的通常形式以下：派生類名（參數總表）：基類名（參數表），內嵌對象名1（參數表），····，內嵌對象名n（參數表），此時構造函數的執行順序是基類的構造函數，內嵌對象成員的構造函數（調用順序按照聲明順序），派生類的構造函數。

EX:

 1 // 基類
 2 class Base
 3 {
 4 public:
 5     Base(){a = 0;b = 0;}
 6     Base(int x,int y)
 7     {
 8        a = x;
 9        b = y;
10     }
11     virtual ~Base(void);
12 
13     void print()
14     {
15        printf("\na = %d b = %d", a, b);
16     }
17 
18 private:
19     int a,b;
20 };
21 
22 // 派生類
23 class Derivel :
24     private Base
25 {
26 public:
27     Derivel():Base(1, 1)
28     {
29        c = 0;
30        d = 0;
31     }
32 
33     Derivel(int x, int y):Base(x + 1, y + 1)
34     {
35        c = x;
36        d = y;
37     }
38 
39     Derivel(int x, int y, int m, int n):Base(m, n)
40     {
41        c = x;
42        d = y;
43     }
44     virtual ~Derivel(void);
45 
46     void print()
47     {
48        Base::print();
49        printf(" c = %d d = %d", c, d);
50     }
51 private:
52     int c,d;
53 };
54 
55 // main
56 int _tmain(int argc, _TCHAR* argv[])
57 {
58     Base obj;
59     obj.print();
60 
61     Derivel obj1;
62     obj1.print();
63 
64     Derivel obj2(10,10);
65     obj2.print();
66 
67     Derivel obj3(10,10,20,20);
68     obj3.print();
69 
70     system("pause");
71     return 0;
72 }

輸出結果：

a = 0 b = 0

a = 1 b = 1 c = 0 d = 0

a = 11 b = 11 c = 10 d = 10

a = 20 b = 20 c = 10 d = 10

• 多重繼承和多重繼承的構造函數

聲明兩個及兩個以上的基類的派生類稱爲多重繼承。其聲明格式通常以下：

Class 派生類名：繼承方式1 基類名1，繼承方式2 基類名2{

}；

注意：當沒有寫明繼承方式的時候按照默認的繼承方式認定，默認的繼承方式是private。

多重繼承中，三種繼承方式對於基類成員在派生類中的訪問性的規則和單繼承是同樣的。

多重繼承的構造函數的執行順序與單繼承構造函數的執行順序相同，也是遵循先執行基類中的構造函數，在執行對象成員的構造函數，最後執行派生類的構造函數的原則。在各個基類之間，則嚴格按照派生類的聲明順序從左到右依次執行。而析構函數的話則是相反的。

EX：

 1 // 基類1
 2 class Base
 3 {
 4 public:
 5     Base()
 6     {
 7        printf("Constructor base.\n");
 8     }
 9 
10     virtual ~Base()
11     {
12        printf("Destructor base.\n");
13     }
14 };
15 
16 // 基類2
17 class Base1
18 {
19 public:
20     Base1()
21     {
22        printf("Constructor base1.\n");
23     }
24 
25     ~Base1()
26     {
27        printf("Destructor base1.\n");
28     }
29 };
30 
31 // 派生類
32 class Derivel :
33     private Base,Base1
34 {
35 public:
36     Derivel()
37     {
38        printf("Constructor derivel.\n");
39     }
40 
41     virtual ~Derivel()
42     {
43        printf("Destructor derivel.\n");
44     }
45 };
46 
47 // main
48 int _tmain(int argc, _TCHAR* argv[])
49 {
50     Derivel *a = new Derivel();
51     delete a;
52 
53     system("pause");
54     return 0;
55 }

輸出結果：

Constructor base.

Constructor base1.

Constructor derivel.

Destructor derivel.

Destructor base1.

Destructor base.