繼承

1. 繼承的概念及定義
- 1.1 繼承的概念
- 1.2 繼承的定義
- - 1.2.1 定義格式
  - 1.2.2 繼承關系和訪問限定符
  - 1.2.3 繼承基類成員訪問方式的變化
2. 基類和派生類物件賦值轉換
3. 繼承中的作用域
4. 派生類的默認成員函式
5. 繼承與友元
6. 繼承與靜態成員
7. 復雜的菱形繼承及菱形虛擬繼承
- 7.1 虛擬繼承解決資料冗余和二義性的原理
8. 繼承的總結和反思

1. 繼承的概念及定義

1.1 繼承的概念

繼承(inheritance)機制是面向物件程式設計使代碼可以復用的最重要的手段，它允許程式員在保持原有類（父類）特性的基礎上進行擴展，增加功能，這樣產生新的類，稱派生類（子類），繼承呈現了面向物件程式設計的層次結構，體現了由簡單到復雜的認知程序，以前我們接觸的復用都是函式復用，繼承是類設計層次的復用，（C++是一個面向物件的語言，其中三大特性為：封裝、繼承、多型，目前已經學習了前兩個，封裝的本質為了能夠更好的管理，資料和方法都放到類中進行管理，在通過訪問限定符進行限制，繼承的本質就是想要讓代碼的復用性更高）

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

class Person{
public: 
	void Print() 
	{ 
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected: 
	string _name = "peter"; // 姓名 
	int _age = 18; // 年齡
}; 
// 繼承后父類的Person的成員（成員函式+成員變數）都會變成子類的一部分，這里體現出了Student和Teacher復用了Person的成員，

class Student : public Person
{
protected:
	int _stuid; // 學號
};

class Teacher : public Person
{
protected: 
	int _jobid; // 工號
};
int main()
{ 
	Student s; 
	Teacher t; 
	s.Print(); 
	t.Print();  
	return 0; 
}

在這里插入圖片描述

1.2 繼承的定義

1.2.1 定義格式

下面我們看到Person是父類，也稱作基類，Student是子類，也稱作派生類，
在這里插入圖片描述

1.2.2 繼承關系和訪問限定符

在這里插入圖片描述

1.2.3 繼承基類成員訪問方式的變化

在這里插入圖片描述
總結

基類private成員在派生類中無論以什么方式繼承都是不可見的，這里的不可見是指基類的私有成員還是被繼承到了派生類物件中，但是語法上限制派生類物件不管在類里面還是類外面都不能去訪問它，
基類private成員在派生類中是不能被訪問，如果基類成員不想在類外直接被訪問，但需要在派生類中能訪問，就定義為protected，可以看出保護成員限定符是因繼承才出現的，
實際上面的表格我們進行一下總結會發現，基類的私有成員在子類都是不可見，基類的其他成員在子類的訪問方式 == Min(成員在基類的訪問限定符，繼承方式)，public > protected > private，
使用關鍵字class時默認的繼承方式是private，使用struct時默認的繼承方式是public，不過最好顯示的寫出繼承方式，
在實際運用中一般使用都是public繼承，幾乎很少使用protetced/private繼承，也不提倡使用protetced/private繼承，因為protetced/private繼承下來的成員都只能在派生類的類里面使用，實際中擴展維護性不強，

2. 基類和派生類物件賦值轉換

派生類物件可以賦值給基類的物件 / 基類的指標 / 基類的參考，這里有個形象的說法叫切片或者切割，寓意把派生類中父類那部分切來賦值過去，
基類物件不能賦值給派生類物件
基類的指標可以通過強制型別轉換賦值給派生類的指標，但是必須是基類的指標是指向派生類物件時才是安全的，（因為當你指向父類的時候，是有可能發生越界情況的，因為子類中或許有屬于自己的一部分成員變數，父類中是沒有的，）

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

class Person{
protected: 
	string _name; // 姓名 
	string _sex; // 性別 
	int _age; // 年齡
};
class Student : public Person
{
public : 
	int _No ; // 學號
};
void Test()
{
	Student s;

	// 1.子類物件可以賦值給父類物件/指標/參考 
	Person p = s;
	Person* pp = &s;
	Person& rp = s;

	//2.基類物件不能賦值給派生類物件 
	//s = p;   直接報錯

	// 3.基類的指標可以通過強制型別轉換賦值給派生類的指標 
	pp = &s;
	Student* ps1 = (Student*)pp; // 這種情況轉換時可以的，
	ps1->_No = 10;

	// 這種情況轉換時雖然可以，但是會存在越界訪問的問題,程式會崩
	pp = &p;
	Student* ps2 = (Student*)pp;
	ps2->_No = 10;
}
int main()
{
	Test();
	return 0;
}

在這里插入圖片描述
把最后的指標指向父類，在強制轉換為子類的代碼屏蔽掉就不會崩了，

3. 繼承中的作用域

在繼承體系中基類和派生類都有獨立的作用域，
子類和父類中有同名成員，子類成員將屏蔽父類對同名成員的直接訪問，這種情況叫隱藏，也叫重定義，（在子類成員函式中，可以使用基類::基類成員顯示訪問）
需要注意的是如果是成員函式的隱藏，只需要函式名相同就構成隱藏，
注意在實際中在繼承體系里面最好不要定義同名的成員，

// Student的_num和Person的_num構成隱藏（重定義）關系
//可以看出這樣代碼雖然能跑，但是非常容易混淆
#include<iostream>
#include<string>
using namespace std;

class Person
{
protected: 
	string _name = "小李子"; // 姓名 
	int _num = 111; // 身份證號
}; 
class Student : public Person
{
public: void Print() 
{ 
	cout<<" 姓名:"<<_name<< endl;
	cout<<" 身份證號:"<<Person::_num<< endl; 
	cout<<" 學號:"<<_num<<endl; 
}
protected: 
	int _num = 999; // 學號
}; 
void Test()
{ 
	Student s1; 
	s1.Print();
};
int main()
{
	Test();
	return 0;
}

在這里插入圖片描述
需要注意的是如果是成員函式的隱藏，只需要函式名相同就構成隱藏
一道題來解釋：

B中的fun和A中的fun不是構成多載，因為不是在同一作用域（不要一看到函式名相同，引數不同就認為是函式多載）
B中的fun和A中的fun構成隱藏，成員函式滿足函式名相同就構成隱藏

class A
{ 
public: 
	void fun() 
	{ 
		cout << "func()" << endl; 
	} 
}; 
class B : public A
{
public: 
	void fun(int i)
	{ 
		cout << "func(int i)->" << i << endl; 
	}
}; 
void Test()
{ 
	B b; 
	b.fun(10); 
};

在這里插入圖片描述

4. 派生類的默認成員函式

6個默認成員函式，“默認”的意思就是指我們不寫，編譯器會變我們自動生成一個，那么在派生類中，這幾個成員函式是如何生成的呢？

派生類的建構式必須呼叫基類的建構式初始化基類的那一部分成員，如果基類沒有默認的建構式，則必須在派生類建構式的初始化串列階段顯示呼叫，
派生類的拷貝建構式必須呼叫基類的拷貝構造完成基類的拷貝初始化，
派生類的operator=必須要呼叫基類的operator=完成基類的復制，
派生類的解構式會在被呼叫完成后自動呼叫基類的解構式清理基類成員，因為這樣才能保證派生類物件先清理派生類成員再清理基類成員的順序，
派生類物件初始化先呼叫基類構造再調派生類構造，（初始化的順序不是真正定義的順序，宣告才是）
派生類物件析構清理先呼叫派生類析構再調基類的析構，（先定義的后析構）

在這里插入圖片描述

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

class Person
{
public: 
	Person(const char* name = "peter") 
		: _name(name) 
	{ 
		cout << "Person()" << endl;
	}  
	
	Person(const Person& p) 
		: _name(p._name) 
	{ 
		cout << "Person(const Person& p)" << endl; 
	}  
	
	Person& operator=(const Person& p) 
	{ 
		cout << "Person operator=(const Person& p)" << endl; 
		if (this != &p)
		{
			_name = p._name;
			return *this;
		}
    } 
	
	~Person() 
	{ 
		cout << "~Person()" << endl; 
	}
protected: string _name; // 姓名
};

class Student : public Person
{
public: 
	Student(const char* name, int num) 
		: Person(name)
		, _num(num) 
	{ 
		cout << "Student()" << endl; 
	} 
	
	Student(const Student& s) 
		: Person(s)
		, _num(s._num) 
	{ 
		cout << "Student(const Student& s)" << endl;
	}
	Student& operator = (const Student& s) 
	{
		cout << "Student& operator= (const Student& s)" << endl; 
		if (this != &s) 
		{
			Person::operator=(s); 
			_num = s._num;
		} 
		return *this;
	}
	~Student() 
	{ 
		cout << "~Student()" << endl; 
	}protected: 
		int _num; //學號
};
void Test ()
{ 
	Student s1 ("jack", 18); 
	cout << endl;

	Student s2 (s1); 
	cout << endl;

	Student s3 ("rose", 17); 
	s1 = s3 ;
	cout << endl;
}

int main()
{
	Test();
	return 0;
}

在這里插入圖片描述

5. 繼承與友元

友元關系不能繼承，也就是說基類友元不能訪問子類私有和保護成員
在這里插入圖片描述

6. 繼承與靜態成員

基類定義了static靜態成員，則整個繼承體系里面只有一個這樣的成員，無論派生出多少個子類，都只有一個static成員實體，

#include<iostream>
#include<string>
using namespace std;
class Person{
public: Person() 
{ 
	++_count; 
}
protected:
	string _name; // 姓名
public : 
	static int _count; // 統計人的個數，
};
int Person :: _count = 0;
class Student : public Person
{
protected : int _stuNum ; // 學號
};
class Graduate : public Student
{
protected : string _seminarCourse ; // 研究科目
};
void TestPerson()
{
	Student s1 ; 
	Student s2 ; 
	Student s3 ; 
	Graduate s4 ; 
	cout <<" 人數 :"<< Person ::_count << endl; 
	Student ::_count = 0; 
	cout <<" 人數 :"<< Person ::_count << endl;
}

int main()
{
	TestPerson();
	return 0;
}

在這里插入圖片描述

7. 復雜的菱形繼承及菱形虛擬繼承

單繼承：一個子類只有一個直接父類時稱這個繼承關系為單繼承
在這里插入圖片描述
多繼承：一個子類有兩個或以上直接父類時稱這個繼承關系為多繼承

菱形繼承：菱形繼承是多繼承的一種特殊情況，

菱形繼承的問題：從下面的物件成員模型構造，可以看出菱形繼承有資料冗余和二義性的問題，在Assistant的物件中Person成員會有兩份，
在這里插入圖片描述

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

class Person{
public: string _name; // 姓名
}; 
class Student : public Person
{
protected : int _num ; //學號
};
class Teacher : public Person
{
protected : int _id ; // 職工編號
};
class Assistant : public Student, public Teacher
{
protected : string _majorCourse ; // 主修課程
};
void Test ()
{
	// 這樣會有二義性無法明確知道訪問的是哪一個
	//Assistant a ; 
	//a._name = "peter"; 
	
	// 需要顯示指定訪問哪個父類的成員可以解決二義性問題，但是資料冗余問題無法解決,且是一種指標不治本的手段 
	a.Student::_name = "xxx"; 
	a.Teacher::_name = "yyy";
}

虛擬繼承可以解決菱形繼承的二義性和資料冗余的問題，如上面的繼承關系，在Student和Teacher的繼承Person時使用虛擬繼承，即可解決問題，需要注意的是，虛擬繼承不要在其他地方去使用，
在這里插入圖片描述

class Person
{
public: string _name; // 姓名
};
class Student : virtual public Person
{
protected : int _num ; //學號
};
class Teacher : virtual public Person
{
protected : int _id ; // 職工編號
};
class Assistant : public Student, public Teacher
{
protected : string _majorCourse ; // 主修課程
};
void Test ()
{ 
	Assistant a; 
	a._name = "peter";
}

7.1 虛擬繼承解決資料冗余和二義性的原理

class A
{ 
public: int _a; 
}; 

// class B : public A
class B : virtual public A
{
public: int _b;
}; 
// class C : public A
class C : virtual public A
{
public: int _c;
}; 
class D : public B, public C
{
public: int _d;
};
int main()
{ 
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4; 
	d._d = 5; 
	return 0;
}

在不加virtual的情況下，來計算D這個類的大小，可以發現是20個位元組（在32位平臺上）
在這里插入圖片描述

調出記憶體監視視窗
在這里插入圖片描述
加上virtual之后，再來深入的了解一下虛擬繼承是如何來解決資料冗余與二義性的問題的，

①加上virtual之后的D類大小是多少呢？答案是24個位元組，不是應該消除一個重復的_a嗎？變為16個位元組嗎？
在這里插入圖片描述
為什么呢？調出監視視窗，
這里可以分析出D物件中將A放到的了物件組成的最下面，這個A同時屬于B和C，那么B和C如何去找到公共的A呢？這里是通過了B和C的兩個指標（原先存放_a位置的指標），指向的一張表，這兩個指標叫虛基表指標，這兩個表叫虛基表，虛基表中存的偏移量，通過偏移量可以找到下面的A，
在這里插入圖片描述

8. 繼承的總結和反思

很多人說C++語法復雜，其實多繼承就是一個體現，有了多繼承，就存在菱形繼承，有了菱形繼承就有菱形虛擬繼承，底層實作就很復雜，所以一般不建議設計出多繼承，一定不要設計出菱形繼承，否則在復雜度及性能上都有問題，
多繼承可以認為是C++的缺陷之一，很多后來的OO語言都沒有多繼承，如Java，
繼承和組合

public繼承是一種is-a的關系，也就是說每個派生類物件都是一個基類物件，
組合是一種has-a的關系，假設B組合了A，每個B物件中都有一個A物件，
（is-a關系可以理解為什么是什么的意思，比如：奔馳、寶馬是車，has-a可以理解為什么有什么的意思，比如：車有一個輪胎）
優先使用物件組合，而不是類繼承 ，（因為代碼需要保證高內聚，低耦合特性）
繼承允許你根據基類的實作來定義派生類的實作，這種通過生成派生類的復用通常被稱為白箱復用(white-box reuse)，術語“白箱”是相對可視性而言：在繼承方式中，基類的內部細節對子類可見
，繼承一定程度破壞了基類的封裝，基類的改變，對派生類有很大的影響，派生類和基類間的依賴關系很強，耦合度高（這樣并不好，因為一旦一個地方的代碼出現問題，由于兩者之間的關系緊密，就有可能導致修改起來過于復雜，考慮的因素也將很多），
物件組合是類繼承之外的另一種復用選擇，新的更復雜的功能可以通過組裝或組合物件來獲得，物件組合要求被組合的物件具有良好定義的介面，這種復用風格被稱為黑箱復用(black-box
reuse)，因為物件的內部細節是不可見的，物件只以“黑箱”的形式出現，
組合類之間沒有很強的依賴關系，耦合度低，優先使用物件組合有助于你保持每個類被封裝，
**實際盡量多去用組合，組合的耦合度低，代碼維護性好，**不過繼承也有用武之地的，有些關系就適合繼承那就用繼承，另外要實作多型，也必須要繼承，類之間的關系可以用繼承，可以用組合，就用組合，

用代碼在解釋一個is-a關系和has-a關系

// Car和BMW Car和Benz構成is-a的關系 
class Car
{ 
protected: string _colour = "白色"; // 顏色 
		   string _num = "陜ABIT00"; // 車牌號
};  
class BMW : public Car
{
public: 
	void Drive() 
	{
		cout << "好開-操控" << endl;
	} 
}; 
class Benz : public Car
{
public: 
	void Drive() 
	{
		cout << "好坐-舒適" << endl;
	} 
}; 
// Tire和Car構成has-a的關系  
class Tire
{
protected: 
	string _brand = "Michelin"; // 品牌 
	size_t _size = 17; // 尺寸 
};  
class Car
{ 
protected: 
	string _colour = "白色"; // 顏色
	string _num = "陜ABIT00"; // 車牌號
	Tire _t; // 輪胎
};

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

標籤：其他

上一篇：寫給學弟學妹們的職場生存套路，請務必提高警惕！

下一篇：Linux-信號的捕捉-信號的阻塞-volatile關鍵字

C++---繼承

繼承

1. 繼承的概念及定義

1.1 繼承的概念

1.2 繼承的定義

1.2.1 定義格式

1.2.2 繼承關系和訪問限定符

1.2.3 繼承基類成員訪問方式的變化

2. 基類和派生類物件賦值轉換

3. 繼承中的作用域

4. 派生類的默認成員函式

5. 繼承與友元

6. 繼承與靜態成員

7. 復雜的菱形繼承及菱形虛擬繼承

7.1 虛擬繼承解決資料冗余和二義性的原理

8. 繼承的總結和反思