1.繼承的概念及定義

1.1繼承的概念

繼承(inheritance)機制是面向?qū)ο蟪绦蛟O(shè)計使代碼可以復(fù)用的最重要的手段，它允許程序員在保 持原有類特性的基礎(chǔ)上進行擴展，增加功能，這樣產(chǎn)生新的類，稱派生類。繼承呈現(xiàn)了面向?qū)ο?程序設(shè)計的層次結(jié)構(gòu)，體現(xiàn)了由簡單到復(fù)雜的認(rèn)知過程。以前我們接觸的復(fù)用都是函數(shù)復(fù)用，繼 承是類設(shè)計層次的復(fù)用。

class Person
{
public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;}
protected:string _name = "peter"; // 姓名int _age = 18; ?// 年齡
};class Student : public Person
{
protected:int _stuid; // 學(xué)號
};                         //student類public繼承person類class Teacher : public Person
{
protected:int _jobid; // 工號
};                         //student類public繼承person類int main()
{Student s;Teacher t;s.Print();  //在類外調(diào)用繼承的person的print函數(shù)t.Print();return 0;
}

1.2 繼承定義?

1.2.1定義格式

下面我們看到Person是父類，也稱作基類。Student是子類，也稱作派生類。

1.2.2繼承關(guān)系和訪問限定符?

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

1. 基類private成員在派生類中無論以什么方式繼承都是不可見的。這里的不可見是指基類的私 有成員還是被繼承到了派生類對象中，但是語法上限制派生類對象不管在類里面還是類外面 都不能去訪問它。

2. 基類private成員在派生類中是不能被訪問，如果基類成員不想在類外直接被訪問，但需要在 派生類中能訪問，就定義為protected。可以看出保護成員限定符是因繼承才出現(xiàn)的。

3. 實際上面的表格我們進行一下總結(jié)會發(fā)現(xiàn)，基類的私有成員在子類都是不可見?；惖钠渌?成員在子類的訪問方式 == Min(成員在基類的訪問限定符，繼承方式)，

public > protected > private。

4. 使用關(guān)鍵字class時默認(rèn)的繼承方式是private，使用struct時默認(rèn)的繼承方式是public，不過 最好顯示的寫出繼承方式。

5. 在實際運用中一般使用都是public繼承，幾乎很少使用protetced/private繼承，也不提倡 使用protetced/private繼承，因為protetced/private繼承下來的成員都只能在派生類的類里 面使用，實際中擴展維護性不強。?

主要使用public繼承：

// 實例演示三種繼承關(guān)系下基類成員的各類型成員訪問關(guān)系的變化 ?
class Person
{
public :void Print (){cout<<_name <<endl;}
protected :string _name ; // 姓名
private :int _age ; // 年齡
};//class Student : protected Person   原public變成protected，private不可見//class Student : private Person     原public，protected全變成private，不可見class Student : public Person       //不變
{
protected :int _stunum ; // 學(xué)號
};

2.基類和派生類對象賦值轉(zhuǎn)換?

1.派生類對象 可以賦值給 基類的對象 / 基類的指針 / 基類的引用。這里有個形象的說法叫切片 或者切割。寓意把派生類中父類那部分切來賦值過去。

2.基類對象不能賦值給派生類對象。

3.基類的指針或者引用可以通過強制類型轉(zhuǎn)換賦值給派生類的指針或者引用。但是必須是基類 的指針是指向派生類對象時才是安全的。

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

3.繼承中的作用域?

1. 在繼承體系中基類和派生類都有獨立的作用域。（父子類的同名成員函數(shù)不構(gòu)成函數(shù)重載，函數(shù)重載要求兩個函數(shù)需要在同一作用域）！！！！！！！！！！！！！！！！

2. 子類和父類中有同名成員，子類成員將屏蔽父類對同名成員的直接訪問！！！！！！！，這種情況叫隱藏， 也叫重定義。（在子類成員函數(shù)中，可以使用 基類::基類成員 顯示訪問）

3. 需要注意的是如果是成員函數(shù)的隱藏，只需要函數(shù)名相同就構(gòu)成隱藏。

4. 注意在實際中在繼承體系里面最好不要定義同名的成員。

// Student的_num和Person的_num構(gòu)成隱藏關(guān)系，可以看出這樣代碼雖然能跑，但是非常容易混淆
class Person
{
protected :string _name = "小李子"; // 姓名int _num = 111; ? // 身份證號
};class Student : public Person
{
public:void Print(){cout<<" 姓名:"<<_name<< endl;cout<<" 身份證號:"<<Person::_num<< endl;  //這里使用了顯示調(diào)用父類的_num，如果沒有Person：：，會因為隱藏，調(diào)用子類的_num：999cout<<" 學(xué)號:"<<_num<<endl;}
protected:int _num = 999; // 學(xué)號，定義了同名對象
};void Test()
{Student s1;s1.Print();
};

// B中的fun和A中的fun不是構(gòu)成重載，因為不是在同一作用域
// B中的fun和A中的fun構(gòu)成隱藏，成員函數(shù)滿足函數(shù)名相同就構(gòu)成隱藏。
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 Test()
{B b;b.fun(10); //這里先調(diào)用B的fun（int i），然后里面顯示調(diào)用了A的fun（）
};

4.派生類的默認(rèn)成員函數(shù)?

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

1. 派生類的構(gòu)造函數(shù)必須調(diào)用基類的構(gòu)造函數(shù)初始化基類的那一部分成員。如果基類沒有默認(rèn) 的構(gòu)造函數(shù)，則必須在派生類構(gòu)造函數(shù)的初始化列表階段顯示調(diào)用。

2. 派生類的拷貝構(gòu)造函數(shù)必須調(diào)用基類的拷貝構(gòu)造完成基類的拷貝初始化。

3. 派生類的operator=必須要調(diào)用基類的operator=完成基類的復(fù)制。

4. 派生類的析構(gòu)函數(shù)會在被調(diào)用完成后自動調(diào)用基類的析構(gòu)函數(shù)清理基類成員。因為這樣才能 保證派生類對象先清理派生類成員再清理基類成員的順序。

5. 派生類對象初始化先調(diào)用基類構(gòu)造再調(diào)派生類構(gòu)造。//先父后子！！！！！！

6. 派生類對象析構(gòu)清理先調(diào)用派生類析構(gòu)再調(diào)基類的析構(gòu)。//先子后父！！！！！！

7. 因為后續(xù)一些場景析構(gòu)函數(shù)需要構(gòu)成重寫，重寫的條件之一是函數(shù)名相同(這個我們后面會講 解)。那么編譯器會對析構(gòu)函數(shù)名進行特殊處理，處理成destrutor()，所以父類析構(gòu)函數(shù)不加 virtual的情況下，子類析構(gòu)函數(shù)和父類析構(gòu)函數(shù)構(gòu)成隱藏關(guān)系。

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 )  //這里需要顯示調(diào)用父類的初始化列表來初始化父類繼承給子類的成員, _num(num )     //子類自己的成員（非繼承）{cout<<"Student()" <<endl;}Student(const Student& s): Person(s)      //這里使用了父類的拷貝構(gòu)造，并使用了隱式類型轉(zhuǎn)換，（因為父類拷貝構(gòu)造函數(shù)只有一 個參數(shù)，s會先被隱式類型轉(zhuǎn)換為person類型，產(chǎn)生臨時變量，臨時變量再來通過父類的拷貝構(gòu)造完成構(gòu)造, _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);   //顯示調(diào)用父類的operator=（）_num = s ._num;}return *this ;} ~Student(){cout<<"~Student()" <<endl;}// 調(diào)完后會自動調(diào)用父類的析構(gòu)函數(shù)
protected :int _num ; //學(xué)號
};void Test ()
{Student s1 ("jack", 18);Student s2 (s1);Student s3 ("rose", 17);s1 = s3 ;
}

5.繼承與友元?

友元關(guān)系不能繼承，也就是說基類友元不能訪問子類私有和保護成員

class Student;
class Person
{
public:friend void Display(const Person& p, const Student& s);
protected:string _name; // 姓名
};
class Student : public Person
{
protected:int _stuNum; // 學(xué)號
};
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);
}

6. 繼承與靜態(tài)成員?

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

class Person
{
public :Person () {++ _count ;}
protected :string _name ; // 姓名
public :static int _count; // 統(tǒng)計人的個數(shù)。
};int Person :: _count = 0; //static成員初始化class Student : public Person
{
protected :int _stuNum ; // 學(xué)號
};class Graduate : public Student
{
protected :string _seminarCourse ; // 研究科目
};
void TestPerson()
{Student s1 ;Student s2 ;Student s3 ;Graduate s4 ;cout <<" 人數(shù) :"<< Person ::_count << endl;Student ::_count = 0;cout <<" 人數(shù) :"<< Person ::_count << endl;
}

?7.復(fù)雜的菱形繼承及菱形虛擬繼承

?單繼承：一個子類只有一個直接父類時稱這個繼承關(guān)系為單繼承

多繼承：一個子類有兩個或以上直接父類時稱這個繼承關(guān)系為多繼承

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

菱形繼承的問題：從下面的對象成員模型構(gòu)造，可以看出菱形繼承有數(shù)據(jù)冗余和二義性的問題。 在Assistant的對象中Person成員會有兩份。

?虛擬繼承可以解決菱形繼承的二義性和數(shù)據(jù)冗余的問題。如上面的繼承關(guān)系，在Student和 Teacher的繼承Person時使用虛擬繼承，即可解決問題。需要注意的是，虛擬繼承不要在其他地 方去使用。

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

7.1虛擬繼承解決數(shù)據(jù)冗余和二義性的原理?

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

下圖是菱形繼承的內(nèi)存對象成員模型：這里可以看到數(shù)據(jù)冗余：

下圖是菱形虛擬繼承的內(nèi)存對象成員模型：這里可以分析出D對象中將A放到的了對象組成的最下 面，這個A同時屬于B和C，那么B和C如何去找到公共的A呢？這里是通過了B和C的兩個指針，指 向的一張表。這兩個指針叫虛基表指針，這兩個表叫虛基表。虛基表中存的偏移量。通過偏移量 可以找到下面的A。?

1.由圖可知，由虛擬繼承所得，B.C.D都含有同一個A（存儲在最下方）

2.先來看B：

? 2.1 第二行存儲的是d繼承的B中的_b的數(shù)值

? 2.2 第一行存儲的是虛基表指針

? ?

3.再來看B中存儲的虛基表指針

? 由第一行得，指針指向的地址為00bc5f50；

? ?3.1 第一行什么都沒存儲

? 3.2? 第二行存儲的是虛基表指針到A的距離（偏移量）！！！！！！！！！！！！

詳解：?

1.虛基表指針的地址是 0x005EF75C；

2.A的地址是0x005EF770；

可得兩地址的距離為（十進制）16*2-12=20（原來為16進制表示，C表示12）

3.再回到虛基表第二行存儲的偏移量是16進制下的14，轉(zhuǎn)換為十進制為16+4=20

可得：偏移量和兩地址間的距離相等！！！！！！！！！！！！！！！！！！！！

8.繼承的總結(jié)和反思?

繼承和組合：

1.public繼承是一種is-a的關(guān)系。也就是說每個派生類對象都是一個基類對象。

2.組合是一種has-a的關(guān)系。假設(shè)B組合了A，每個B對象中都有一個A對象。

3.優(yōu)先使用對象組合，而不是類繼承 。

4.繼承允許你根據(jù)基類的實現(xiàn)來定義派生類的實現(xiàn)。這種通過生成派生類的復(fù)用通常被稱 為白箱復(fù)用(white-box reuse)。術(shù)語“白箱”是相對可視性而言：在繼承方式中，基類的 內(nèi)部細(xì)節(jié)對子類可見 。繼承一定程度破壞了基類的封裝，基類的改變，對派生類有很 大的影響。派生類和基類間的依賴關(guān)系很強，耦合度高。

5.對象組合是類繼承之外的另一種復(fù)用選擇。新的更復(fù)雜的功能可以通過組裝或組合對象 來獲得。對象組合要求被組合的對象具有良好定義的接口。這種復(fù)用風(fēng)格被稱為黑箱復(fù) 用(black-box reuse)，因為對象的內(nèi)部細(xì)節(jié)是不可見的。對象只以“黑箱”的形式出現(xiàn)。 組合類之間沒有很強的依賴關(guān)系，耦合度低。優(yōu)先使用對象組合有助于你保持每個類被 封裝。

6.實際盡量多去用組合。組合的耦合度低，代碼維護性好。不過繼承也有用武之地的，有 些關(guān)系就適合繼承那就用繼承，另外要實現(xiàn)多態(tài)，也必須要繼承。類之間的關(guān)系可以用 繼承，可以用組合，就用組合。

// Car和BMW Car和Benz構(gòu)成is-a的關(guān)系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構(gòu)成has-a的關(guān)系class Tire{protected:string _brand = "Michelin"; ?// 品牌size_t _size = 17; ? ? ? ? // 尺寸};class Car{protected:string _colour = "白色"; // 顏色string _num = "陜ABIT00"; // 車牌號Tire _t; // 輪胎  組合}; 

9.小習(xí)題?

?

p1和p3雖然相等，但指向的對象范圍卻是不同的，p1指向base1，p3指向整個d?