• C++【继承】

    目录

    一、什么是继承

    二、继承关系和访问限定符 

    三、继承中的作用域（隐藏的理解）

    四、赋值兼容转换

    1.子类对象可以赋值给父类对象/指针/引用

    2.基类对象不能赋值给派生类对象

    3.基类的指针可以通过强制类型转换赋值给派生类的指针

    五、派生类的默认成员函数

    1.构造函数 

    2.拷贝构造 

    3.赋值

    4.析构函数

    5.取地址的重载

    六、继承与友元

    七、继承与静态成员

    八、单继承、多继承、菱形继承

    如何定义一个不能被继承的类？ 

    练习（多继承中指针偏移问题）

    菱形继承的问题

    菱形虚拟继承

    小总结 

    一、什么是继承

    继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保
    持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用

    比方说学校人员管理系统

    学生有name,tel,id,address属性，和宿舍号，专业和班级属性

    老师有name,tel,id,address属性，和职称，院系属性

    后勤有name,tel,id,address属性，和职能属性

    我们看到上面三个类之间由有重复的属性，这里我们就可以用到我们继承的思想。

    就是将每一个人都具备的信息都提取出来，放到一个公共的类里面去，不妨称为person类。那我们每一个单独的类就不用定义了，就直接去继承这个person类，从而获取共有数据和方法。

    这个person类就叫做父类或者基类。

    下面这些学生，老师，后勤类就是子类或者派生类。

    继承体现的是类设计层次的定义和复用

    1. class Person
    2. {
    3. public:
    4. 	void Print()
    5. 	{
    6. 		cout << "name:" << _name << endl;
    7. 		cout << "age:" << _age << endl;
    8. 	}
    9. 	string _name = "peter"; // 姓名
    10. 	int _age = 18;  // 年龄
    11. 	//....
    12. };
    13.  
    14. //继承Person类
    15. class Student : public Person
    16. {
    17. protected:
    18. 	int _stuid; // 学号
    19. };
    20.  
    21. //继承Person类
    22. class Teacher : public Person
    23. {
    24. protected:
    25. 	int _jobid; // 工号
    26. };
    27.  
    28. int main()
    29. {
    30. 	Student s;
    31. 	s._name = "催逝员";
    32. 	s._age = 18;
    33. 	s.Print();
    34.  
    35. 	Teacher t;
    36. 	t._name = "杭老师";
    37. 	t._age = 40;
    38. 	t.Print();
    39.  
    40. 	return 0;
    41. }

     

    二、继承关系和访问限定符 

    也就是说继承方式和访问限定符组合一下，会有9种

    类成员/继承方式

    public继承

    protected继承

    private继承

    基类的public成员

    派生类的public成员

    派生类的protected成员

    派生类的private成员

    基类的protected成员

    派生类的protected成员

    派生类的protected成员

    派生类的private成员

    基类的private成员

    在派生类中不可见

    在派生类中不可见

    在派生类中不可见

    1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
    2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
    3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected> private。
    4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
    5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。 

    （取访问限定符和继承限定符中权限小的那一个）

     JAVA面向对象【三大特性】_桜キャンドル淵的博客-CSDN博客_java中面向对象的特性

    C++由于语言创建比较早，所以设计得非常繁琐，后面Java会更加方便（可以对比一下上面Java的面向对象）。

    C++其实关注共有继承就行

    protected/private       类外面不能访问 类里面可以访问

    不可见                         类里面和外面都无法访问

    1. class Person
    2. {
    3. public:
    4. 	void Print()
    5. 	{
    6. 		cout << "name:" << _name << endl;
    7. 		cout << "age:" << _age << endl;
    8. 	}
    9. protected:
    10. //private:
    11. 	string _name = "peter"; // 姓名
    12. 	int _age = 18;  // 年龄
    13. 	//....
    14. };
    15.  
    16. class Student : public Person
    17. {
    18. public:
    19. 	void Set(const char* name, int age)
    20. 	{
    21. 		_name = name;
    22. 		_age = age;
    23. 	}
    24. protected:
    25. 	int _stuid; // 学号
    26. };
    27.  
    28. // protected/private  类外面不能访问 类里面可以访问
    29. // 不可见              类里面和外面都无法访问
    30. int main()
    31. {
    32. 	Student s;
    33. 	s.Set("张三", 18);
    34. 	s._name = "张三";
    35. 	s._age = 18;
    36. 	s.Print();
    37.  
    38. 	return 0;
    39. }

    上面父类中的属性是protected，就是在类外面无法访问，在类里面可以访问（父类本身和继承的子类可以访问）

    所以我们上面的main中的s._name和s._age会报错的

    现在我们将父类的_name和_age改成私有private属性

    1. class Person
    2. {
    3. public:
    4. 	void Print()
    5. 	{
    6. 		cout << "name:" << _name << endl;
    7. 		cout << "age:" << _age << endl;
    8. 	}
    9. //protected:
    10. private:
    11. 	string _name = "peter"; // 姓名
    12. 	int _age = 18;  // 年龄
    13. 	//....
    14. };
    15.  
    16. class Student : public Person
    17. {
    18. public:
    19. 	void Set(const char* name, int age)
    20. 	{
    21. 		_name = name;
    22. 		_age = age;
    23. 	}
    24. protected:
    25. 	int _stuid; // 学号
    26. };
    27.  
    28. // protected/private  类外面不能访问 类里面可以访问
    29. // 不可见              类里面和外面都无法访问
    30. int main()
    31. {
    32. 	Student s;
    33. 	s.Set("张三", 18);
    34. 	s._name = "张三";
    35. 	s._age = 18;
    36. 	s.Print();
    37.  
    38. 	return 0;
    39. }

    只有person中能够访问私有属性，其他继承person的类都是没有权限访问的，更不用说main中的在类外面访问了。

    私有成员的意义是什么？

    私有成员的意义就是不希望被子类继承的成员，可以设计成私有

    保护成员的意义是什么？

    基类中想给子类复用，但是又不像暴露直接访问的成员，就应该定义成保护

    三、继承中的作用域（隐藏的理解）

    1. 在继承体系中基类和派生类都有独立的作用域。
    2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）

    （就相当于是在局部变量和全局变量重名的时候，优先使用局部变量）
    3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
    4. 注意在实际中在继承体系里面最好不要定义同名的成员。

    1. class Person
    2. {
    3.  
    4. protected:
    5.     string _name = "小李子"; // 姓名
    6.     int _num = 111; 	   // 身份证号
    7. };
    8.  
    9. class Student : public Person
    10. {
    11. public:
    12.     void Print()
    13.     {
    14.         cout << " 姓名:" << _name << endl;
    15.         cout << " 学号:" << _num << endl; // 999
    16.         cout << " 身份证号:" << Person::_num << endl; // 111
    17.         cout <<" _num"<<_num<
    18.     }
    19. protected:
    20.     int _num = 999; // 学号
    21. };
    22. int main()
    23. {
    24.     Student s;
    25.     s.Print();
    26.     return 0;
    27. }

     

    1.  1、两个fun构成函数重载？ -- 不对 函数重载要求在同一作用域
    2.  2、两个fun构成隐藏  -- ok
    3.  
    4. class A
    5. {
    6. public:
    7.     void fun()
    8.     {
    9.         cout << "func()" << endl;
    10.     }
    11. };
    12.  
    13. class B : public A
    14. {
    15. public:
    16.     void fun(int i)
    17.     {
    18.         cout << "func(int i)->" << i << endl;
    19.     }
    20. };
    21.  
    22. int main()
    23. {
    24.     B b;
    25.     b.fun(10);
    26.     b.A::fun();
    27.     return 0;
    28. };

    继承不会把父类当中的内容拷贝到子类中。

    自类生成一个对象，对象当中没有成员函数，对象当中只有成员变量，编译器在计算其对象模型的时候，就会把父类和子类中的成员全部都计算进去。成员函数就会被放到公共的代码段中的。你可以认为你在去公共代码段找对应的代码的时候，会受到域的限制。

    父类很少回去定义私有成员，除非你并不想让子类用 

    四、赋值兼容转换

    1.派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。

            这里有个形象的说法叫切片或者切割。

            寓意把派生类中父类那部分切来赋值过去。
    2.基类对象不能赋值给派生类对象。

    （父类对象不可以赋值给子类对象，因为我们的父类对象比我们的子类对象少了一部分成员变量和函数，是不支持的）
    基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。

    但是必须是基类的指针是指向派生类对象时才是安全的。

    这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。

    1.子类对象可以赋值给父类对象/指针/引用

    1.子类对象可以赋值给父类对象/指针/引用

    特殊，虽然是不同类型，但是不是隐式类型转换

    这个建立在共有继承的情况下，也就是is a 的关系 也就是每一个子类对象都是一个特殊的父类对象

    父类有的成员子类都有 所以将子类的对象给父类对象，就相当于是一种切片，将子类对象中的父类对象的部分拷贝给父类对象

    1. #include 
    2. using namespace std;
    3. class Person
    4. {
    5. protected :
    6.     string _name; // 姓名
    7.     string _sex; // 性别
    8.     int _age; // 年龄
    9. };
    10. class Student : public Person
    11. {
    12. public :
    13.     int _No ; // 学号
    14. };
    15. void Test ()
    16. {
    17.     Student sobj ;
    18. // 1.子类对象可以赋值给父类对象/指针/引用
    19. //特殊，虽然是不同类型，但是不是隐式类型转换
    20. //这个建立在共有继承的情况下，也就是is a 的关系
    21. //也就是每一个子类对象都是一个特殊的父类对象
    22. //父类有的成员子类都有
    23. //所以将子类的对象给父类对象，就相当于是一种切片，将子类对象中的父类对象的部分拷贝给父类对象
    24.     Person pobj = sobj ;
    25.     Person* pp = &sobj;
    26.     //如果是隐式类型转换这就不能通过
    27.     Person& rp = sobj;
    28.  
    29.  
    30. //这里的隐式类型转换不能通过就跟我们下面这个代码是一个道理
    31. //    int i=0;
    32.     //i转换给d会产生一个临时变量，临时变量会具有常性，所以不能转换
    33. //    double &d =i;
    34.     
    35. }

    这里用指针和引用也同样都是切片，也就是上面代码中的

        Person pobj = sobj ;
        Person* pp = &sobj;

    就是将子类对象中的父类那一部分切出来，返回回去

    这里的切片并不是说将子类中的父类那一部分给切走了！而是拷贝给父类对象，对于子类本身来说，并没有任何的影响。

    2.基类对象不能赋值给派生类对象

    1. #include 
    2. using namespace std;
    3. class Person
    4. {
    5. protected :
    6.     string _name; // 姓名
    7.     string _sex; // 性别
    8.     int _age; // 年龄
    9. };
    10. class Student : public Person
    11. {
    12. public :
    13.     int _No ; // 学号
    14. };
    15. void Test ()
    16. {
    17.     Student sobj ;
    18.     Person pobj = sobj ;
    19. //2.基类对象不能赋值给派生类对象
    20. //这里我们的pobj是一个基类，也就是父类对象，赋值给子类对象是不可以的！
    21.     sobj = pobj;
    22. }

     

    3.基类的指针可以通过强制类型转换赋值给派生类的指针

    1. #include 
    2. using namespace std;
    3. class Person
    4. {
    5. protected :
    6.     string _name; // 姓名
    7.     string _sex; // 性别
    8.     int _age; // 年龄
    9. };
    10. class Student : public Person
    11. {
    12. public :
    13.     int _No ; // 学号
    14. };
    15. void Test ()
    16. {
    17.     Student sobj ;
    18.     Person pobj = sobj ;
    19.     Person* pp = &sobj;
    20.     //如果是隐式类型转换这就不能通过
    21.     Person& rp = sobj;
    22.     int i=0;
    23.  3.基类的指针可以通过强制类型转换赋值给派生类的指针
    24.     pp = &sobj;
    25.     Student* ps1 = (Student*)pp; // 这种情况转换时可以的。
    26.     ps1->_No = 10;
    27.     pp = &pobj;
    28.     Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
    29.     ps2->_No = 10;
    30. }

    五、派生类的默认成员函数

    6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？
    1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
    2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
    3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
    4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
    5. 派生类对象初始化先调用基类构造再调派生类构造。
    6. 派生类对象析构清理先调用派生类析构再调基类的析构。
    7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系

    1.构造函数 

    子类编译默认生成的构造函数会干什么

    1.自己的成员，跟类和对象一样（内置类型不处理，自定义类型调用对应的构造函数）

    2.继承父类成员，必须调用父类的构造函数初始化。

    1. #include 
    2. #include 
    3. using namespace std;
    4. class Person
    5. {
    6. public :
    7.     Person(const char* name = "peter")
    8.             : _name(name )
    9.     {
    10.         cout<<"Person()" <
    11.     }
    12.     Person(const Person& p)
    13.             : _name(p._name)
    14.     {
    15.         cout<<"Person(const Person& p)" <
    16.     }
    17.     Person& operator=(const Person& p )
    18.     {
    19.         cout<<"Person operator=(const Person& p)"<< endl;
    20.         if (this != &p)
    21.             _name = p ._name;
    22.         return *this ;
    23.     }
    24.     ~Person()
    25.     {
    26.         cout<<"~Person()" <
    27.     }
    28. protected :
    29.     string _name ; // 姓名
    30. };
    31.  
    32. class Student : public Person
    33. {
    34. public :
    35.     Student(const char* name, int num)
    36.             : Person(name )
    37.             , _num(num )
    38.     {
    39.         cout<<"Student()" <
    40.     }
    41.     Student(const Student& s)
    42.             : Person(s)
    43.             , _num(s ._num)
    44.     {
    45.         cout<<"Student(const Student& s)" <
    46.     }
    47.     Student& operator = (const Student& s )
    48.     {
    49.         cout<<"Student& operator= (const Student& s)"<< endl;
    50.         if (this != &s)
    51.         {
    52.             Person::operator =(s);
    53.             _num = s ._num;
    54.         }
    55.         return *this ;
    56.     }
    57.     ~Student()
    58.     {
    59.         cout<<"~Student()" <
    60.     }
    61. protected :
    62.     int _num ; //学号
    63. };
    1. void Test ()
    2. {
    3.     Student s1 ("jack", 18);
    4. }
    5. int main()
    6. {
    7.     Test();
    8. }

    我们观察到它确实调用了父类的构造函数和析构函数 

     

     子类中的继承的父类的成员函数和成员方法，是需要调用父类中的构造函数和析构函数，日过没有默认构造，就会报错

    相当于子类的构造是合成的，父类中的方法有父类中的构造函数去提供，子类中的构造函数由子类自身提供。

     我们上面代码中的

     就是将person类似于一整个匿名函数对象进行构造的。

    2.拷贝构造 

    编译器生成默认的拷贝构造

    1.自己成员，跟类和对象一样（对于内置类型完成值拷贝，自定义类型就调用它的拷贝构造）

    2.继承的父类成员，必须调用父类的拷贝构造！

    派生类，子类当中的成员自己处理。父类中的成员需要调用父类当中的。 

     主函数已经在上面给出，这里只写测试方法

    1. void Test ()
    2. {
    3.     Student s1 ("jack", 18);
    4.     Student s2 (s1);
    5. //    Student s3 ("rose", 17);
    6. //    s1 = s3 ;
    7. }
    8. int main()
    9. {
    10.     Test();
    11. }

     

    我们不妨观察一下上面的主函数中的代码中的显式拷贝构造的部分

     这里我们在拷贝构造的时候，我们就是调用我们前一个知识点（四）中所说的切片的方法，将我们的子类中的person的部分给切片了出来，并进行了初始化（类似于匿名初始化），因为我们的编译器天生就是支持切片操作的，然后我们就实现了子类中的父类的部分调用父类中的拷贝构造函数，我们的子类自己的成员变量和函数就调用我们子类中的自己的部分。

    3.赋值

    编译器默认生成的operator=

    1.自己成员，跟类和对象一样（对于内置类型完成值拷贝，自定义类型就调用它的赋值方法）

    2.继承的父类成员，必须调用父类的赋值！

     （主函数已经在上面给出，这里只写测试方法）

    1. void Test ()
    2. {
    3.     Student s1 ("jack", 18);
    4. //    Student s2 (s1);
    5.     Student s3 ("rose", 17);
    6.     s1 = s3 ;
    7. }
    8. int main()
    9. {
    10.     Test();
    11. }

     我们不妨再来查看一下上面主函数中的复制拷贝的代码部分

     由于这里的同名函数构成了隐藏，所以默认就是子类中的复制构造，所以我们需要指定一下是Person中的赋值构造，不然的话，我们子类中的拷贝构造就会自己调用自己，形成堆栈溢出，产生报错！

    4.析构函数

    子类析构子类的成员对象和方法

    父类析构父类的成员对象和方法

    1、自己成员，跟类一样，内置类型不处理，自定义类型调用他自己的的析构函数。

    2、继承的成员，调用父类析构函数处理。

     （主函数已经在上面给出，这里只写测试方法）

    （这里我们的测试的时候是没有写显式析构父类的，然后我们的测试结果如下）

    1. void Test ()
    2. {
    3.     Student s1 ("jack", 18);
    4.     Student s2 (s1);
    5.     Student s3 ("rose", 17);
    6.     s1 = s3 ;
    7. }
    8. int main()
    9. {
    10.     Test();
    11. }

     

    我们再来看一下上面主代码中的相关的析构部分

    父类中的析构函数

     

     但我们的子类中的析构函数，如果先想要析构父类的，我们如下这样写，但是会报错

     

     析构函数是这四个函数中最特殊的一个。

    1.因为子类的析构函数跟父类的析构函数构成隐藏！

    （这里的报错可能会不准确，应为我们的编译器有时候一些报错判断也混淆了）

    我们只要指定Person::的析构函数就可以了

    为什么我们这里子类和父类的析构函数的名称都不一样，但是会构成隐藏？

     由于后面多态的需要，析构函数的名字会统一处理成destructtor()。

    所以就变成了同名函数，就构成了隐藏！

    为什么我们子类的析构函数有三次，我们的父类的析构函数有六次？

    （这里我们测试的时候是写了显式析构的，所以这里会出现父类的六次析构，和上面的测试结果不同，但是我们这里测试的时候，和我们4.析构函数中的test()函数是一样的！）

     先定义的先初始化，后定义的后初始化，（函数栈帧）

    子类继承了父类，父类的先构造，子类的再构造，子类先析构，父类再析构，符合先构造的后析构，后构造的，先析构。

    不需要显示调用父类的析构函数！！！

    每个子类析构函数后面，会自动调用父类析构函数，这样才能保证先析构子类，再析构父类。

    也就是说，我们这里其实对于同一个对象进行了多次析构，如果我们这里存在有对指针进行空间释放的话，其实会是因为对同一块空间进行多次释放而产生报错的！

     以上的四种行为

    拷给构造和赋值行为是相似的。

    构造函数和析构函数是相似的。

    5.取地址的重载

     取地址的话取的是子类的地址，所以直接用子类的取地址重载父类的就可以了。

    1.  Student * operator& (Student&s)
    2.     {
    3.         return &s;
    4.     }
    1. void Test ()
    2. {
    3.     Student s1 ("jack", 18);
    4.     cout<<&s1<
    5. }
    6. int main()
    7. {
    8.     Test();
    9. }

     

    六、继承与友元

    继承的时候，友元关系并不会被继承下来！

    1. #include
    2. using namespace std;
    3. class Student;
    4. class Person
    5. {
    6. public:
    7.     friend void Display(const Person& p, const Student& s);
    8. protected:
    9.     string _name; // 姓名
    10. };
    11. class Student : public Person
    12. {
    13. protected:
    14.     int _stuNum; // 学号
    15. };
    16. void Display(const Person& p, const Student& s)
    17. {
    18.     cout << p._name << endl;
    19.     cout << s._stuNum << endl;
    20. }
    21. int main()
    22. {
    23.     Person p;
    24.     Student s;
    25.     Display(p, s);
    26. }

    七、继承与静态成员

    静态成员不再对象里面，是在静态区里面。

    这个静态成员可以被继承下来，并且在子类中访问的静态成员和父类中访问的静态成员是同一个！

    1. #include
    2. using namespace std;
    3. class Person
    4. {
    5. public :
    6.     Person () {++ _count ;}
    7. protected :
    8.     string _name ; // 姓名
    9. public :
    10.     static int _count; // 统计人的个数。
    11. };
    12. int Person :: _count = 0;
    13. class Student : public Person
    14. {
    15. protected :
    16.     int _stuNum ; // 学号
    17. };
    18. class Graduate : public Student
    19. {
    20. protected :
    21.     string _seminarCourse ; // 研究科目
    22. };
    23. void TestPerson()
    24. {
    25.     Student s1 ;
    26.     Student s2 ;
    27.     Student s3 ;
    28.     Graduate s4 ;
    29.     cout <<" 人数 :"<< Person ::_count << endl;
    30.     Student ::_count = 0;
    31.     cout <<" 人数 :"<< Person ::_count << endl;
    32. }
    33. int main()
    34. {
    35.     TestPerson();
    36. }

     原本我们的子类对象中的成员属性和我们父类中的成员属性是不同的，

    但是如果是静态成员变量的话，这个父类和子类其实调用的是同一个成员属性，上面的测试代码中的人数在person中是4，然后我们通过子类将_count修改为0，我们父类中的_count也变成了0！

    （无论派生出了多少的子类，派生类都是同一个！）

    1. void TestPerson()
    2. {
    3.     Student s1 ;
    4.     Student s2 ;
    5.     Student s3 ;
    6.     Graduate s4 ;
    7.     cout <<" 人数地址 :"<< &Person ::_count << endl;
    8.     Student ::_count = 0;
    9.     cout <<" 人数地址 :"<< &Person ::_count << endl;
    10. }
    11. int main()
    12. {
    13.     TestPerson();
    14. }

    我们观察到其地址根本就是一样的 

     

     利用这个特性其实我们可以用于统计一共创建了多少个对象。比方说我们的子类创建就将静态成员变量++，那么就可以统计出一共有多少个对象了

    八、单继承、多继承、菱形继承

    1.单继承：一个子类只有一个直接父类时称这个继承关系为单继承

    2.多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

    3.菱形继承：菱形继承是多继承的一种特殊情况。

    如何定义一个不能被继承的类？ 

    1.如何定义一个不能被继承的类？

    这是我们原本的函数

    1. class A
    2. {
    3. protected:
    4.     int _a;
    5. };
    6.  
    7. class B:public A
    8. {
    9.     
    10. };
    11. int main()
    12. {
    13.     return 0;
    14. }

    C++98

    1.父类构造函数私有--子类是不可见的
    2.子类对象实例化，无法调用构造函数
    （在你实例化对象的时候就会报错）

    1. class A
    2. {
    3. // C++98
    4. //1.父类构造函数私有--子类是不可见的
    5. //2.子类对象实例化，无法调用构造函数
    6. //（在你实例化对象的时候就会报错）
    7. //构造函数私有化
    8. private:
    9.     A();
    10. protected:
    11.     int _a;
    12. };
    13.  
    14. class B:public A
    15. {
    16.  
    17. };
    18. int main()
    19. {
    20.     B bb;
    21.     return 0;
    22. }

     c++11增加了一个final关键字

    1. class A final
    2. {
    3. protected:
    4.     int _a;
    5. };
    6.  
    7. class B:public A
    8. {
    9.  
    10. };
    11. int main()
    12. {
    13.     B bb;
    14.     return 0;
    15. }

    练习（多继承中指针偏移问题）

    下面说法正确的是( )

    1. class Base1{public:int _b1;};
    2. class Base2{public:int _b2;};
    3. class Derive :public Base1,public Base2{public :int _d;};
    4. int main(){
    5.     Derive d;
    6.     Base1* p1=&d;
    7.     Base2* p2=&d;
    8.     Derive* p3= &d;
    9.     return 0;
    10. }

    A：p1==p2==p3

    B：p1

    C：p1==p3!=p2

    D：p1!=p2!=p3

    E：编译报错

    F：运行报错

    A和E是互斥的，你知道了切片行为就应该排除A和E，因为这里存在赋值兼容的问题

    （也就是我们上面所讲的，当子类赋值给父类的时候，我们能赋值的，只有子类中继承的父类的那一部分，这里的Base1和Base2明显就是两个不同的父类，其切片所切出的部分是不一样的！）

    这道题问的是切片的指针偏移

    这里我们的Derive先继承了Base1，后继承了Base2

    西安集成的在前面，后继承的在后面

     （这里p1和p3的区别就是p1所指向的仅仅是Base1，但是p3所指向的是Base1,Base2,_d所组成的一整个整体的地址（因为我们的这里的p3所指向的是Derive也就是这一整个的地址），只是在地址上巧合地和p1相同了）

    C  

     这里我们不妨直接将地址打印出来看看

    1. #include
    2. using namespace std;
    3. class Base1{public:int _b1;};
    4. class Base2{public:int _b2;};
    5. class Derive :public Base1,public Base2{public :int _d;};
    6. int main(){
    7.     Derive d;
    8.     cout<<"d："<<&d<
    9.     Base1* p1=&d;
    10.     cout<<"p1："<
    11.     Base2* p2=&d;
    12.     cout<<"p2："<
    13.     Derive* p3= &d;
    14.     cout<<"p3："<
    15.     return 0;
    16. }

    这跟我们上面所分析的结果是一样的 

    所以我们栈动态增长的时候，从低地址往高地址增长，也就是依次将我们的_b1,_b2,_d放入我们的栈中，先放入低地址的位置，然后再放入高地址的位置，然后就变成了我们下面的这个样子。 

     

    菱形继承的问题

    菱形继承会导致数据冗余和二义性

    二义性：这里我们的助教既是学生，又是老师，那其继承的Person类中就不知道这个Person类应该是用学生类中的Person还是老师类中的Person了。

    数据冗余：在我们的Person中有了两份Person的拷贝

    1. #include
    2. using namespace std;
    3. class Person
    4. {
    5. public :
    6.     string _name ; // 姓名
    7. };
    8. class Student : public Person
    9. {
    10. protected :
    11.     int _num ; //学号
    12. };
    13. class Teacher : public Person
    14. {
    15. protected :
    16.     int _id ; // 职工编号
    17. };
    18. class Assistant : public Student, public Teacher
    19. {
    20. protected :
    21.     string _majorCourse ; // 主修课程
    22. };

    这里我们的Student中有一个继承Person的名字属性，Teacher中有一个继承Person的名字属性，所以我们的助教（assistant）根本不知道自己应该用他的学生的名字还是他的老师的名字。

    1. void Test ()
    2. {
    3. // 这样会有二义性无法明确知道访问的是哪一个
    4.     Assistant a ;
    5.     a._name = "peter";
    6. }
    7. int main()
    8. {
    9.     Test();
    10. }

     解决方法

    1. void Test ()
    2. {
    3.     Assistant a ;
    4. // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
    5.     a.Student::_name = "xxx";
    6.     a.Teacher::_name = "yyy";
    7. }
    8. int main()
    9. {
    10.     Test();
    11. }

    菱形虚拟继承

    虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和
    Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地
    方去使用。

    1. #include
    2. using namespace std;
    3. class Person
    4. {
    5. public :
    6.     string _name ; // 姓名
    7. };
    8. class Student : public virtual Person
    9. {
    10. protected :
    11.     int _num ; //学号
    12. };
    13. class Teacher : public virtual Person
    14. {
    15. protected :
    16.     int _id ; // 职工编号
    17. };
    18. class Assistant : public Student, public Teacher
    19. {
    20. protected :
    21.     string _majorCourse ; // 主修课程
    22. };
    23. void Test ()
    24. {
    25. // 这样会有二义性无法明确知道访问的是哪一个
    26.     Assistant a ;
    27.     a._name = "peter";
    28. }
    29. int main()
    30. {
    31.     Test();
    32. }

    就是我们在继承的时候添加了virtual继承方式

    这样是可以编译通过的

    在库函数里面要是有菱形继承的

    但是我们不要去写菱形继承！！！ 

     那么虚继承是如何去解决数据冗余和二义性的问题的呢？

    1. class A
    2. {
    3. public:
    4.     int _a;
    5. };
    6.  class B : public A
    7. {
    8. public:
    9.     int _b;
    10. };
    11.  class C : public A
    12. {
    13. public:
    14.     int _c;
    15. };
    16. class D : public B, public C
    17. {
    18. public:
    19.     int _d;
    20. };
    21.  
    22. int main()
    23. {
    24.     D d;
    25.     d.B::_a = 1;
    26.     d.C::_a = 2;
    27.     d._b = 3;
    28.     d._c = 4;
    29.     d._d = 5;
    30.     return 0;
    31. }

     

    1. #include 
    2. using namespace std;
    3. class A
    4. {
    5. public:
    6.     int _a;
    7. };
    8.  class B : public A
    9. {
    10. public:
    11.     int _b;
    12. };
    13.  class C : public A
    14. {
    15. public:
    16.     int _c;
    17. };
    18. class D : public B, public C
    19. {
    20. public:
    21.     int _d;
    22. };
    23.  
    24. int main()
    25. {
    26.     D d;
    27.     d.B::_a = 1;
    28.     cout<<&d.B::_a<
    29.     d.C::_a = 2;
    30.     cout<<&d.C::_a<
    31. //    d._a=3;
    32. //    cout<<&d._a<
    33.     d._b = 3;
    34.     d._c = 4;
    35.     d._d = 5;
    36.  
    37.     return 0;
    38. }

    这两个a根本就不是同一个！ 

    我们下面将继承方式改成虚拟继承！！ 

    1. #include 
    2. using namespace std;
    3. class A
    4. {
    5. public:
    6.     int _a;
    7. };
    8. // class B : public A
    9. class B : virtual public A
    10. {
    11. public:
    12.     int _b;
    13. };
    14. // class C : public A
    15. class C : virtual public A
    16. {
    17. public:
    18.     int _c;
    19. };
    20. class D : public B, public C
    21. {
    22. public:
    23.     int _d;
    24. };
    25.  
    26. int main()
    27. {
    28.     D d;
    29.     d.B::_a = 1;
    30.     cout<<&d.B::_a<
    31.     d.C::_a = 2;
    32.     cout<<&d.C::_a<
    33.     d._a=3;
    34.     cout<<&d._a<
    35.     d._b = 3;
    36.     d._c = 4;
    37.     d._d = 5;
    38.  
    39.     return 0;
    40. }

     我们发现这个a其实就是同一个a，这个a是被放到一个公共的空间当中去的！

    那我们这里的虚拟继承所花的空间是更多还是更少呢？

    这就好比是你记笔记，你整理笔记，需要比不整理笔记花费更长的时间，但是当你复习回顾的时候，我们可以直接去查找对应位置的笔记，不需要再重新上一遍课。

    所以我们这里其实也是一样的。如果我们的a被多次调用的时候，我们如果没有虚拟继承，就需要将a多次拷贝，但是如果我们使用了虚拟继承，我们的a就只有保存一份，在一定程度上是节省了空间的。  

    为什么我们这里要用偏移量来表示？

    下图是菱形虚拟继承的内存对象成员模型：这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。 

    在切片的时候去寻找A的时候，就是用我们当前的类的地址再加上偏移量去寻找我们的A的地址的。

    比方说我们下面的图中的C类的地址就是加上12（一行是4字节，一共是三行），然后找到我们的A类的地址

    然后我们的B的地址加上20（一行是4字节，一共是5行），找到我们的A类的地址 

    （这里我们是小端存储的，所以我们要将我们找到的地址反着输进去）

    （这里的BCD在内存中的顺序是按照我们的声明的顺序来的）

    上面a这个类就被称为虚基类，相当于我们需要多了一层计算，需要去计算偏移量 

    小总结 

     public继承是一种is-a的关系，也就是说每个派生类对象都是一个基类对象

    也就是（学生is a 人）（玫瑰花 is a 植物）

    组合是一种has-a的关系

    假设B组合了A，那么每一个B中都有一个A

    比方说我们轮胎和车的关系

    我们能说每一辆车都有轮胎，也就是说轮胎是车的组成部分。

    一些类型的关系，既可以认为是is-a，也可以认为是has-a

    vector/list/deque和stack的关系

    我们可以说栈是一个顺序表，也可以说栈有顺序表，（顺序栈）

     可以说栈是一个链表，也可以说栈有链表（链栈）

    可以说栈是一个双端队列，也可以说栈有双端队列。

    那么既可以是is-a，也可以是has-a的时候，尽量使用has-a。

    继承是一种白箱复用，耦合度高，依赖关系强

    组合是一种黑箱复用，耦合度低，依赖关系没有那么强

    黑指的是未知，白指的是已知。

    比方说OJ题，它的测试用例就是一个白箱测试，因为它知道你这个题应该是大概怎么写的，所以它就专门设计了针对于这道题的测试用例。

     我们为了实现低耦合，高内聚，所以最好采用组合的形式

    （高耦合的话，其中的一个模块极有可能会影响另外一个模块。）

    （如果a和b是继承关系，a有10个成员，一个共有9个保护，那如果a变动了，b都可能会发生变化）

    （但如果我们是一个组合，我无法使用你的保护的成员，只能用你的共有，那么只要你不改共有，那么我就不会受到影响）

    1. // Car和BMW Car和Benz构成is-a的关系
    2. class Car{
    3. protected:
    4.     string _colour = "白色"; // 颜色
    5.     string _num = "陕ABIT00"; // 车牌号
    6. };
    7. class BMW : public Car{
    8. public:
    9.     void Drive() {cout << "好开-操控" << endl;}
    10. };
    11. class Benz : public Car{
    12. public:
    13.     void Drive() {cout << "好坐-舒适" << endl;}
    14. };
    1. // Tire和Car构成has-a的关系
    2. class Tire{
    3. protected:
    4.     string _brand = "Michelin"; // 品牌
    5.     size_t _size = 17; // 尺寸
    6. };
    7. class Car{
    8. protected:
    9.     string _colour = "白色"; // 颜色
    10.     string _num = "陕ABIT00"; // 车牌号
    11. //将轮胎设计进去
    12.     Tire _t; // 轮胎
    13. };

  • 相关阅读:
    OAuth2.0和1.0的区别
    原生HTML Select下拉多选 + vue
    节流(Throttle)和防抖(Debounce)
    快速排序（算法与数据结构）
    【Hack The Box】linux练习-- Delivery
    Java面试之JVM篇(offer 拿来吧你)
    1-乙基-3-甲基咪唑醋酸盐([EMIM][Ac])；甲基三辛基醋酸铵[N(1,8,8,8)][Ac]齐岳离子液体
    零基础想系统地学习金融学、量化投资、数据分析、python，需要哪些课程、书籍？有哪些证书可以考？
    jupyterlab教程
    Flink之OperatorState
  • 原文地址：https://blog.csdn.net/weixin_62684026/article/details/127129824