文章目錄

繼承

繼承和組合

繼承

繼承機制：是面向對象程序設計使代碼可以複用的最重要的手段，它允許程序員在保持原有類特性的基礎上進行擴展，增加功能，這樣產生新的類，稱派生類。繼承呈現了面向對象程序設計的層次結構，體現了由簡單到複雜的認知過程。以前我們接觸的複用都是函數複用，繼承是類設計層次的複用。

class Student : public Person 中 Student 爲派生類，public 爲繼承方式，Person 爲基類。

class Person
{
public:
 void Print()
 {
 cout << "name:" << _name << endl;
 cout << "age:" << _age << endl;
 }
protected:
 string _name = "peter"; // 姓名
 int _age = 18; // 年齡
};
// 繼承後父類的Person的成員（成員函數+成員變量）都會變成子類的一部分。這裏體現出了Student和
Teacher複用了Person的成員。下面我們使用監視窗口查看Student和Teacher對象，可以看到變量的複用。
調用Print可以看到成員函數的複用。
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; 
 }

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

總結：

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

基類和派生類對象賦值轉換

派生類對象可以賦值給基類的對象 / 基類的指針 / 基類的引用。這裏有個形象的說法叫切片或者切割。寓意把派生類中父類那部分切來賦值過去。
基類對象不能賦值給派生類對象。
基類的指針可以通過強制類型轉換賦值給派生類的指針。但是必須是基類的指針是指向派生類對象時纔是安全的。這裏基類如果是多態類型，可以使用RTTI(Run-Time Type Information)的dynamic_cast 來進行識別後進行安全轉換。

class Person
{
protected :
 string _name; // 姓名
 string _sex; // 性別
 int _age; // 年齡
};
class Student : public Person
{
public :
 int _No ; // 學號
};
void Test ()
{
 Student sobj ;
 // 1.子類對象可以賦值給父類對象/指針/引用
 Person pobj = sobj ;
 Person* pp = &sobj;
 Person& rp = sobj;
 
 //2.基類對象不能賦值給派生類對象
 sobj = pobj;
 
 // 3.基類的指針可以通過強制類型轉換賦值給派生類的指針
 pp = &sobj;
 Student* ps1 = (Student*)pp; // 這種情況轉換時可以的。
 ps1->_No = 10;
 
 pp = &pobj;
 Student* ps2 = (Student*)pp; // 這種情況轉換時雖然可以，但是會存在越界訪問的問題
 ps2->_No = 10;
 }

繼承中的作用域

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

// Student的_num和Person的_num構成隱藏關係，可以看出這樣代碼雖然能跑，但是非常容易混淆
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();
};

輸出結果爲：
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)
	{
		A::fun();
		cout << "func(int i)->" << i << endl;
	}
};
void Test1()
{
	B b;
	b.fun(10);
};

派生類的默認成員函數

派生類的構造函數必須調用基類的構造函數初始化基類的那一部分成員。如果基類沒有默認的構造函數，則必須在派生類構造函數的初始化列表階段顯示調用。
派生類的拷貝構造函數必須調用基類的拷貝構造完成基類的拷貝初始化。
派生類的operator=必須要調用基類的operator=完成基類的複製。
派生類的析構函數會在被調用完成後自動調用基類的析構函數清理基類成員。因爲這樣才能保證派生類對象先清理派生類成員再清理基類成員的順序。
派生類對象初始化先調用基類構造再調派生類構造。
派生類對象析構清理先調用派生類析構再調基類的析構。

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 Test3()
{
	Student s1("jack", 18);
	Student s2(s1);
	Student s3("rose", 17);
	s1 = s3;
}

繼承和友元

友元不能繼承，也就是說基類友元不能訪問子類私有和保護成員。

class Student;
class Person
{
public:
 friend void Display(const Person& p, const Student& s);
protected:
 string _name; // 姓名
};
class Student : public Person
{
protected:
 int _stuNum; // 學號
};
void Display(const Person& p, const Student& s) {
 cout << p._name << endl;
 cout << s._stuNum << endl; }
void main()
{
 Person p;
 Student s;
 Display(p, s);
}

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

菱形繼承

單繼承

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

多繼承

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

菱形繼承

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

菱形繼承存在的問題：從下面的對象成員模型構造，可以看出菱形繼承有數據冗餘和二義性的問題。在Assistant的對象中Person成員會有兩份。

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"; 
}

虛擬繼承解決數據冗餘和二義性的原理

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; }

繼承和組合

public繼承是一種is-a的關係。也就是說每個派生類對象都是一個基類對象。
組合是一種has-a的關係。假設B組合了A，每個B對象中都有一個A對象。
優先使用對象組合，而不是類繼承。
繼承允許你根據基類的實現來定義派生類的實現。這種通過生成派生類的複用通常被稱爲白箱複用。術語“白箱”是相對可視性而言：在繼承方式中，基類的內部細節對子類可見。繼承一定程度破壞了基類的封裝，基類的改變，對派生類有很大的影響。派生類和基類間的依賴關係很強，耦合度高。
對象組合是類繼承之外的另一種複用選擇。新的更復雜的功能可以通過組裝或組合對象來獲得。對象組合要求被組合的對象具有良好定義的接口。這種複用風格被稱爲黑箱複用，因爲對象的內部細節是不可見的。對象只以“黑箱”的形式出現。組合類之間沒有很強的依賴關係，耦合度低。優先使用對象組合有助於你保持每個類被封裝。
實際儘量多去用組合。組合的耦合度低，代碼維護性好。不過繼承也有用武之地的，有些關係就適合繼承那就用繼承，另外要實現多態，也必須要繼承。類之間的關係可以用繼承，可以用組合，就用組合。

Car和BMW Car和Benz構成is-a的關係

 class Car{
 protected:
 string _colour = "白色"; // 顏色
 string _num = "12345678"; // 車牌號
  };
 
 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 = "12345678"; // 車牌號
 Tire _t; // 輪胎
 };

C++三大特性- - -繼承

文章目錄

繼承

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

基類和派生類對象賦值轉換

繼承中的作用域

派生類的默認成員函數

繼承和友元

菱形繼承

單繼承

多繼承

菱形繼承

繼承和組合

(Linux) 高級IO

(Linux)網絡基礎- - - 網絡層（IP協議）

（Linux網絡協議）網絡基礎（應用層、傳輸層）

C++紅黑樹(圖文詳解)（校招必看）

求Sn=a+aa+aaa+aaaa+aaaaa的前5項之和（C語言入門）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結