繼承

繼承是面向對象複用的重要手段。通過繼承定義一個類，繼承是類型之間的關係建模，共享公有的東西，實現各自本質不同的東西。

三種繼承關係：public、protected、private

三種繼承關係下基類成員在派生類的訪問關係變化。

public繼承：基類的public成員仍爲public成員、基類的protected仍爲protected成員、基類的private成員不可見。

protected繼承：基類的public變爲protected、基類的protected變爲protected、基類的private不可見。

private繼承：基類的public變爲private、基類的protected變爲private、基類的private不可見。

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

class Person
{
public :
	void Display ()
	{
		cout<< _name <<endl;
	}
protected :
	string _name ; // 姓名
private :
	int _age ; // 年齡
};
//class Student : protected Person
//class Student : private Person
class Student : public Person
{
protected :
	int _num ; // 學號
};

int main()
{
	Person p;
	p.Display();
	Student s;
	s.Display();
	return 0;
}

 

總結：

1. 基類的私有成員在派生類中是不能被訪問的，如果一些基類成員不想被基類對象直接訪問，但需要在派生類中能訪問，就定義爲保

護成員。可以看出保護成員限定符是因繼承纔出現的。

2. public繼承是一個接口繼承，保持is-a原則，每個父類可用的成員對子類也可用，因爲每個子類對象也都是一個父類對象。

3. protetced/private繼承是一個實現繼承，基類的部分成員並未完全成爲子類接口的一部分，是 has-a 的關係原則，所以非特殊情

況下不會使用這兩種繼承關係，在絕大多數的場景下使用的都是公有繼承。

4. 不管是哪種繼承方式，在派生類內部都可以訪問基類的公有成員和保護成員，但是基類的私有成員存在但是在子類中不可見（不能

訪問）。

5. 使用關鍵字class時默認的繼承方式是private，使用struct時默認的繼承方式是public，不過最好顯示的寫出繼承方式。

6. 在實際運用中一般使用都是public繼承，極少場景下才會使用protetced/private繼承.

繼承與轉換--賦值兼容規則--public繼承

1. 子類對象可以賦值給父類對象（切割/切片）

2. 父類對象不能賦值給子類對象

3. 父類的指針/引用可以指向子類對象

4. 子類的指針/引用不能指向父類對象（可以通過強制類型轉換完成）

class Person
{
public :
	void Display ()
	{
		cout<<_name <<endl;
	}
protected :
	string _name ; // 姓名
};
class Student : public Person
{
public :
	int _num ; // 學號
};
void Test ()
{
	Person p ;
	Student s ;
	// 1.子類對象可以賦值給父類對象（切割 /切片）
	p = s ;
	// 2.父類對象不能賦值給子類對象
	//s = p;
	 3.父類的指針/引用可以指向子類對象
	Person* p1 = &s;
	Person& r1 = s;
	// 4.子類的指針/引用不能指向父類對象（可以通過強制類型轉換完成）
	Student* p2 = (Student*)& p;
	Student& r2 = (Student&) p;
}
int main()
{
	Test();
	return 0;
}

繼承體系中派生類的六個默認成員函數

class Person
{
public :
	Person(const char* name)
	: _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;
}
private :
	int _num ; //學號
};
void Test ()
{
	Student s1 ("jack", 18);
	Student s2 (s1);
	Student s3 ("rose", 17);
	s1 = s3 ;
}
int main()
{
	Test();
	return 0;
}

單繼承&多重繼承

1. 單繼承--一個子類只有一個直接父類時稱這個繼承關係爲單繼承

2. 多繼承--一個子類有兩個或以上直接父類時稱這個繼承關係爲多繼承

菱形繼承存在二義性和數據冗餘的問題。

虛繼承--解決菱形繼承二義性和數據冗餘問題。

1、--解決了在菱形體系中子類對象包含多份父類對象的數據冗餘和浪費空間問題。

2--使用虛繼承解決數據冗餘問題也帶來了性能上的損耗。