C++ 類的繼承

  在C++中，可重用性是通過繼承這一機制來實現的，因此，繼承是C++中一個重要的部分。

1.派生類的聲明

聲明一個派生類的一般格式為：

class 派生類名：繼承方式  基類名
{
    //派生類新增的數據成員和成員函數
};

 從已有類派生出新類時，可以在派生類內完成以下功能：

  （1）可以增加新的數據成員

  （2）可以增加新的成員函數

  （3）可以對基類的成員進行重定義

  （4）可以改變基類成員在派生類中的訪問屬性

2.基類成員在派生類中的訪問屬性

  從基類繼承來的成員在派生類中的訪問屬性是由繼承方式控制的，下面我們來看看類的繼承方式。

 類的繼承方式有public(公有繼承)，protected(保護繼承)，private(私有繼承)3種，不同的繼承方式導致不同訪問屬性的基類成員在派生類中的訪問屬性也不同。

（1）公有繼承的訪問規則

（2）保護繼承的訪問規則

（3）私有繼承的訪問規則

根據上面三個表格我們不難看出：

a.基類中的私有成員：

 無論哪種繼承方式，都不允許派生類繼承，即在派生類中是不可以直接訪問的。

b.基類中的公有成員：

 公有繼承時，基類中的所有公有成員在派生類中仍以公有成員的身份出現

 私有繼承時，基類中的所有公有成員在派生類中都是以私有成員的身份出現

 保護繼承時，基類中的所有公有成員在派生類中都是以保護成員的身份出現

c.基類中的保護成員：

 公有繼承時，基類中的所有公有成員在派生類中仍以保護成員的身份出現

 私有繼承時，基類中的所有公有成員在派生類中都是以私有成員的身份出現

 保護繼承時，基類中的所有公有成員在派生類中都是以保護成員的身份出現

下面我們通過實例來看看公有繼承：

#include<iostream>

using namespace std;

class B
{
public:
	void geta(int a1)
	{
		a = a1;
	}
	void showa()
	{
		cout << "a=" << a << endl;
	}
private:
	int a;
};

class D :public B
{
public:
	void getab(int a1, int b1)
	{
		geta(a1);
		b = b1;
	}
	void showab()
	{
		cout << "a=" << a << endl;//錯誤，a在類中為不可直接訪問成員
		cout << "b=" << b << endl;
	}
private:
	int b;
};

void Funtest()
{
	D d;
	d.getab(10, 24);
	d.showa();
	d.showab();
}

int main()
{
	Funtest();
	system("pause");
	return 0;
}

上面程序中在D內訪問了a是錯誤的，在這里再次說明：派生類公有繼承了基類，但是不代表派生類可以訪問基類私有成員，企圖訪問是非法的。

3.派生類的構造函數和析構函數：

我們先通過一個例子來看看派生類的構造函數和析構函數的調用順序吧：

#include<iostream>

using namespace std;

class B
{
public:
	B(int n)
	{
		cout << "B()" << endl;
		i = n;
	}
	~B()
	{
		cout << "~B()" << endl;
	}
	void showi()
	{
		cout << i << endl;
	}
private:
	int i;
};

class D :public B
{
public:
	D(int n, int m) :B(m)
	{
		cout << "D()" << endl;
		j = n;
	}
	~D()
	{
		cout << "~D()" << endl;
	}
	void showj()
	{
		cout << j << endl;
	}
private:
	int j;
};

void Funtest()
{
	D d(50, 60);
	d.showi();
	d.showj();
}

int main()
{
	Funtest();
	system("pause");
	return 0;
}

大家分析一下這段代碼的結果是什么呢？

從結果中可以看到：

 當創建派生類對象時，首先調用基類的構造函數，然后再調用派生類的構造函數，當撤銷派生類對象時，則先調用派生類的析構函數，隨后調用基類的析構函數。

那么為什么調用析構函數時順序是相反的呢？

 對于析構函數來說，基類的構造函數并不了解子類的結構，所以子類必須先于基類完成清理工作，一步一步向上推進。

4.派生類的構造函數與析構函數

 在上面的程序中我們可以看到派生類內有自定義的構造函數，并且帶了參數。派生類不能繼承基類中的構造函數和析構函數。當基類含有帶參數的構造函數時，派生類必須定義構造函數，以提供把參數傳遞給基類構造函數的途徑。

C++中，派生類構造函數的一般格式為：

派生類名（參數總表）：基類名（參數表）

{

   //派生類新增數據成員的初始化語句

}

基類構造函數的參數通常來源于派生類構造函數的參數總表

說明：

（1）基類沒有缺省的構造函數，派生類必須要在初始化列表中顯式給出基類名和參數列表

（2）基類沒有定義構造函數，則派生類也可以不用定義，全部使用缺省構造函數

（3）基類定義了帶有形參表的構造函數，派生類就一定定義構造函數（可以看上面那段程序幫助理解哦）

5.繼承體系中的作用域

（1）在繼承體系中基類和派生類是兩個不同的作用域（這也是為什么基類的私有成員無論被哪種方式繼承時都不可以在派生類中直接訪問的原因）

（2）派生類和基類中有同名成員時，派生類成員將屏蔽基類對成員的直接訪問。在派生類成員函數中，可通過下面這種方式訪問：

              基類::基類成員

（3）當然，在實際中，我們最好不要使用同名成員來定義對象

6.賦值兼容規則：

（1）子類對象賦值給父類對象：

Base b;
Derived d;
b=d;

（2）子類對象可初始化父類對象的引用：

B &br = d;

（3）父類指針可以指向子類對象：

B *pb = &d;

（4）若函數形參為父類對象或對象的引用時，調用函數時可以用子類對象作實參

class B
{
  public:
     int i;
     //……
};

class D:public B
{ };
 
void fun(B &bb)
{
  cout<<bb.i<<endl;
}
在調用函數fun()時可以用子類的對象d作為實參。輸出子類D的對象d賦給父類的數據成員i的值。

7.友元與繼承

友元關系不能繼承，即基類友元不能訪問派生類私有和保護成員

8.單繼承、多繼承、菱形繼承、

（1）單繼承：一個子類只有一個直接父類時稱這個繼承關系為單繼承

（2）多繼承：一個子類有兩個或以上直接父類時稱這個繼承關系為多繼承

  多重繼承的一般形式為：
   class類名l：訪問控制類名2，訪問控制類名3，…訪問控制類名n
   (
   …／／定義派生類自己的成員
   }；

多繼承構造函數的調用順序與單繼承構造函數的調用順序相同，也是遵循先調用基類的構造函數，再調用對象成員的構造函數，最后調用派生類構造函數的原則。

（3）菱形繼承

例如，B為類C1、C2的直接父類，C1、C2又同時是D的父類。

因為菱形繼承存在二義性和數據冗余的問題，所以引出了下面的虛擬繼承

9.虛擬繼承

  虛擬繼承是多重繼承中特有的概念。虛擬基類是為解決多重繼承而出現的。如:類D繼承自類C1、C2，而類C1、C2都繼承自類B，因此在類D中兩次出現類B中的變量和函數。為了節省內存空間，可以將C1、C2對B的繼承定義為虛擬繼承，而B就成了虛擬基類。

 虛基類的聲明：

class 派生類名：virtual 繼承方式 類名

{

 // ……

}

說明：關鍵字virtual與繼承方式關鍵字的先后順序無關，它只是說明是“虛擬繼承”。

下面我們通過例子來深度理解一下虛擬繼承是怎么一回事：

#include<iostream>
using namespace std;

class B
{
public:
	B()
	{
		a = 1;
		cout << "B a = " << a << endl;
	}
protected:
	int a;
};

class B1 :public B
{
public:
	B1()
	{
		a += 10;
		cout << "B1 a = " << a << endl;
	}
};

class B2 :public B
{
public:
	B2()
	{
		a += 20;
		cout << "B2 a = " << a << endl;
	}
};

class D :public B1, public B2
{
public:
	D()
	{
		cout << "B1::a = " << B1::a << endl;
		cout << "B2::a = " << B2::a << endl;
	}
};

void Funtest()
{
	D d;
}

int main()
{
	Funtest();
	system("pause");
	return 0;
}

程序運行結果如下：

由于在類D中同時存在著類B1、B2的數據成員a，因此在D中的構造函數中輸出a時必須加上“類名::”，指出是哪一個數據成員a，否則就會出現二義性。如果將上面的子類D改成下面形式便會出錯：

class D :public B1, public B2
{
public:
	D()
	{
		cout << "D a = " << a << endl;//錯誤
	}
};

下面使用關鍵字來看這個程序：

#include<iostream>
using namespace std;

class B
{
public:
	B()
	{
		a = 1;
		cout << "B a = " << a << endl;
	}
protected:
	int a;
};

class B1 : virtual public B
{
public:
	B1()
	{
		a += 10;
		cout << "B1 a = " << a << endl;
	}
};

class B2 :virtual public B
{
public:
	B2()
	{
		a += 20;
		cout << "B2 a = " << a << endl;
	}
};

class D :public B1, public B2
{
public:
	D()
	{
		cout << "D a = " << a << endl;

		//cout << "B1::a = " << B1::a << endl;
		//cout << "B2::a = " << B2::a << endl;
	}
};

void Funtest()
{
	D d;
}

int main()
{
	Funtest();
	system("pause");
	return 0;
}

程序結果運行如下：

上述程序中使用了關鍵字，這樣的話，從B1、B2派生出的類D指繼承基類B一次，就是說基類B的數據成員a只保留一份。

虛擬繼承解決了在菱形繼承體系里面子類對象包含多份父類對象的數據冗余和空間浪費的問題。

這是我對于繼承的理解，如有不足，還請各位多多指教