• C++ 三大特性之继承(二)重点：菱形虚拟继承

    目录

    1.派生类的默认成员函数

      (1)构造函数

        [1]规则1

        [2]规则2

        [3]规则3

        [4]总结

      (2)拷贝构造函数

        [1]规则1

        [2]规则2

      (3)赋值运算符重载函数

      (4)总结

    2.继承与友元

    3.继承与静态成员

    4.复杂的菱形继承及菱形虚拟继承

      (1)普通多继承

        [1]使用方法

        [2]对象模型验证

      (2)菱形继承

        [1]使用方法

        [2]对象模型验证

        [3]缺陷及解决办法

      (3)普通虚拟继承(超重要)

        [1]使用方法

        [2]对象模型分析       

      (4)菱形虚拟继承

        [1]使用方法

        [2]对象模型验证

        [3]总结 

    5.继承的总结

            本节最重要的两点就是派生类的默认成员函数和菱形虚拟继承。特别是菱形虚拟继承，一点更要把文字和图片结合着看，图片中的地址一定要看清楚。(本文代码均在win10系统vs2019中验证)

    1.派生类的默认成员函数

            在前面的文章中就讲过当涉及到资源管理时，类的拷贝构造函数、赋值运算符重载、析构函数一定要用户根据实际情况显式定义。在这里着重讲一下当不涉及资源管理时前两个函数和构造函数在派生类中的要点，其余的默认构造函数都比较好理解。

            这里强调一点：构造哪个类的对象，就调用哪个类的构造方法。给哪个类拷贝构造对象，就调用哪个类的拷贝构造方法。析构哪个类的对象，就调用哪个类的析构函数。

      (1)构造函数

        [1]规则1

            基类中没有显示定义构造函数，子类中可以不定义。

            代码一：当成员变量均为public，可以通过对象.变量名赋值。成员变量是protected和private时可以在类中提供公有的设置函数。

    1. //代码一
    2. #include "iostream"
    3. using namespace std;
    4.  
    5. class Base {
    6. public:
    7. 	int a;
    8. };
    9.  
    10. class Son :public Base {
    11. public:
    12. 	int b;
    13. };
    14. int main() {
    15. 	Son s;
    16. 	s.a = 1;
    17. 	s.b = 2;
    18. }

        [2]规则2

            基类中显式定义了无参或全缺省构造函数，子类可以不定义。全缺省和无参只能存在一个。

            代码二：

    1. //代码二
    2. #include "iostream"
    3. using namespace std;
    4.  
    5. class Base {
    6. public:
    7. 	int a;
    8. public:
    9. 	Base(int _a = 4)
    10. 		:a(_a)
    11. 	{}
    12. 	
    13. 	//Base() {}
    14. };
    15.  
    16. class Son :public Base {
    17. public:
    18. 	int b;
    19. };
    20. int main() {
    21. 	Son s;
    22. 	s.a = 1;
    23. 	s.b = 2;
    24. 	cout << s.a << endl;//1
    25. 	cout << s.b << endl;//2
    26. }

        [3]规则3

            当基类构造函数有参数且不是全缺省，子类必须显示提供构造函数，并且在子类构造函数的初始化列表的位置显式调用基类的构造函数将子类对象中从基类继承下来的部分初始化。

            代码三：注意必须要在子类的初始化列表调用父类的构造函数。

    1. //代码三
    2. #include "iostream"
    3. using namespace std;
    4.  
    5. class Base {
    6. public:
    7. 	int a;
    8. public:
    9. 	Base(int _a)
    10. 		:a(_a)
    11. 	{}
    12. };
    13.  
    14. class Son :public Base {
    15. public:
    16. 	int b;
    17. public:
    18. 	Son(int _a,int _b)
    19. 		:Base(_a)
    20. 		,b(_b)
    21. 	{}
    22. };
    23. int main() {
    24. 	Son s(1,2);
    25. 	cout << s.a << endl;//1
    26. 	cout << s.b << endl;//2
    27. }

        [4]总结

            当默认成员函数没有显示定义，编译器会自动给出(其实这句话不太准确，因为当编译器觉得默认成员函数没用，它就不会生成了)，但如果显示定义，编译器就不会再出。当编译器调用自己给出的默认构造函数，会将成员变量赋默认值。如果你显示定义基类构造函数且不是空参或全缺省，子类却不显式定义构造函数。编译器因为没有合适的方法调用，就不知道该给变量赋什么值，就会报错。 

      (2)拷贝构造函数

            拷贝构造函数要分两种情况，当类涉及资源管理时，拷贝构造函数必须用户显示提供，因为编译器给出的默认拷贝构造函数可能会造成浅拷贝，这一点在之前的文章已经验证过了。

            这里给出的三条规则均是不涉及资源管理的类中的情况。

        [1]规则1

            基类中没有显示定义拷贝构造函数，子类中可以不定义。        

            代码四：此时编译器会自动生成。

    1. //代码四
    2. #include "iostream"
    3. using namespace std;
    4.  
    5. class Base {
    6. public:
    7. 	int a;
    8.  
    9. };
    10.  
    11. class Son :public Base {
    12. public:
    13. 	int b;
    14.  
    15. };
    16. int main() {
    17. 	Son s1;
    18. 	s1.a = 1;
    19. 	s1.b = 2;
    20. 	Son s2(s1);
    21. 	cout << s2.a << endl;//1
    22. 	cout << s2.b << endl;//2
    23. }

        [2]规则2

            基类中显示定义拷贝构造函数，子类中必须定义。并且要在子类的拷贝构造函数中显示调用基类的拷贝构造函数，用参数中从基类继承下来的部分赋值。

            代码五：

    1. //代码五
    2. #include "iostream"
    3. using namespace std;
    4.  
    5. class Base {
    6. public:
    7. 	int a;
    8. public:
    9. 	Base(int _a)
    10. 		:a(_a)
    11. 	{
    12. 		cout << "父类构造" << endl;
    13. 	}
    14.  
    15. 	Base(const Base& bas)
    16. 		:a(bas.a)
    17. 	{
    18. 		cout << "父类拷贝" << endl;
    19. 	}
    20. };
    21.  
    22. class Son :public Base {
    23. public:
    24. 	int b;
    25. public:
    26. 	Son(int _a, int _b)
    27. 		:Base(_a)
    28. 		, b(_b)
    29. 	{
    30. 		cout << "子类构造" << endl;
    31. 	}
    32.  
    33. 	Son(const Son& son)
    34. 		:Base(son)
    35. 		, b(son.b)
    36. 	{
    37. 		cout << "子类拷贝" << endl;
    38. 	}
    39. };
    40.  
    41. int main() {
    42. 	Son s1(4, 5);
    43. 	cout << "=================" << endl;
    44. 	Son s2(s1);
    45. 	cout << s2.b << endl;//2
    46. }

            代码五结果显示：为什么给子类构造对象，先调用的是父类的构造函数？其实不是，仔细观察代码，只是因为在打印子类构造函数的文本前，子类构造函数在初始化列表中调用父类构造函数了，所以才是这种结果。这里请记住开头红色背景的那段话。

     

      (3)赋值运算符重载函数

            赋值运算符函数重载也要分两种情况，当类涉及资源管理时，赋值运算符函数重载必须用户显示提供，因为编译器给出的默认赋值运算符函数重载可能会造成浅拷贝。这里给出的是不涉及资源管理的情况。

            代码六：注意这里不可以用 *this = son 来赋值，因为*this就是Son类型，自然调用的是Son类的赋值运算符重载，这不就死循环了吗？

    1. //代码五
    2. #include "iostream"
    3. using namespace std;
    4.  
    5. class Base {
    6. public:
    7. 	int a;
    8. public:
    9. 	Base(int _a)
    10. 		:a(_a)
    11. 	{}
    12.  
    13. 	Base(const Base& bas)
    14. 		:a(bas.a)
    15. 	{}
    16.  
    17. 	Base& operator=(const Base& bas) {
    18. 		if (this != &bas) {
    19. 			a = bas.a;
    20. 		}
    21. 		return *this;
    22. 	}
    23. };
    24.  
    25. class Son :public Base {
    26. public:
    27. 	int b;
    28. 	int* p;
    29. public:
    30. 	Son(int _a, int _b)
    31. 		:Base(_a)
    32. 		, b(_b)
    33. 	{
    34. 		p = new int[10];
    35. 	}
    36.  
    37. 	Son(const Son& son)
    38. 		:Base(son)
    39. 		, b(son.b)
    40. 	{
    41. 		p = new int[100];
    42. 	}
    43.  
    44. 	Son& operator=(const Son& son) {
    45. 		if (this != &son) {
    46. 			//使用Base的赋值运算符用son中从Base继承来的变量给*this中的从Base继承来的部分赋值
    47. 			Base::operator=(son);
    48. 			//这里不可以使用 *this = son
    49.  
    50. 			//先释放原本空间
    51. 			delete[] p;
    52. 			//为子类新增加的变量赋值
    53. 			p = new int[100];
    54. 			b = 12;
    55. 		}
    56. 		return *this;
    57. 	}
    58.  
    59.  
    60. };
    61. int main() {
    62. 	Son s1(4, 5);
    63. 	cout << "=================" << endl;
    64. 	Son s2(3, 4);
    65. 	s2 = s1;
    66. }

      (4)总结

            1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
            2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
            3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
            4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
            5. 派生类对象初始化先调用派生类构造再调基类构造。
            6. 派生类对象析构清理先调用派生类析构再调基类的析构

    2.继承与友元

            这里只有一句话：友元关系不能继承。

    3.继承与静态成员

            这里也是一句话：静态对象在整个程序中只有一份，为多个对象共享。

            代码七：这里把三个对象中的num地址都打印出来发现，三个num地址一样。

    1. //代码七
    2. #include "iostream"
    3. using namespace std;
    4.  
    5. class AAA {
    6. public:
    7. 	static int num;
    8. };
    9.  
    10. int AAA::num = 10;
    11.  
    12. class AA : public AAA {
    13. public:
    14. 	void Add() {
    15. 		num++;
    16. 	}
    17. };
    18.  
    19. class A : public AA {
    20. public:
    21. 	void Add() {
    22. 		num++;
    23. 	}
    24. };
    25.  
    26. int main() {
    27. 	AAA a1;
    28. 	AA a2;
    29. 	A a3;
    30. 	cout << &a1.num << endl;
    31. 	cout << &a2.num << endl;
    32. 	cout << &a3.num << endl;
    33. }

    4.复杂的菱形继承及菱形虚拟继承

            继承分为单继承和多继承。单继承是一个子类只有一个父类，多继承是一个子类有多个父类。

            

      (1)普通多继承

        [1]使用方法

            class 子类名 : 限定符 父类1，修饰符 父类2 {}

            代码八：父类都必须给出限定符，否则编译器的默认继承方式是private

    1. //代码八
    2. #include "iostream"
    3. using namespace std;
    4.  
    5. class B1 {
    6. public:
    7. 	int a;
    8. };
    9. class B2 {
    10. public:
    11. 	int b;
    12. };
    13. class S :public B1, public B2 {
    14. public:
    15. 	int c;
    16. };
    17.  
    18. int main() {
    19. 	S s;
    20. 	s.a = 1;
    21. 	s.b = 2;
    22. 	s.c = 3;
    23. }

        [2]对象模型验证

            如下验证代码八对象模型：

            必备知识：这里内存窗口中的是小端模式下的16进制数字，咱们的常规写法是高位在前，低位在后，这个刚好相反。将它们写成常规写法就是：00 00 00 01。

            注意类中继承顺序是先B1，后B2。

            单继承s对象模型如图所示，对象中B1继承的在前，B2继承的在后，s自身新增的在最后。这点从内存窗口中的赋值就可以看出来。

      (2)菱形继承

            菱形继承如下图所示：

        [1]使用方法

            在继承体系中，S1单继承B，S2单继承B，G多继承S1和S2。

            代码九：

    1. //代码九
    2. #include "iostream"
    3. using namespace std;
    4.  
    5. class B {
    6. public:
    7. 	int a;
    8. };
    9. class S1 :public B {
    10. public:
    11. 	int b;
    12. };
    13. class S2 :public B {
    14. public:
    15. 	int c;
    16. };
    17. class G :public S1, public S2 {
    18. public:
    19. 	int d;
    20. };
    21.  
    22. int main() {
    23. 	G g;
    24. 	g.S1::a = 1;
    25. 	g.b = 3;
    26.  
    27. 	g.S2::a = 2;
    28. 	g.c = 4;
    29.  
    30. 	g.d = 5;
    31. }

            按照普通多继承的对象模型来推测菱形继承的对象模型：

        [2]对象模型验证

            利用内存窗口验证代码九：可以发现，确实跟猜想一样，内存中的排列顺序是：S1::a，S1::b，S2::a，S2::c，G::d。恰好与推测的模型一致。

        [3]缺陷及解决办法

            菱形继承具有二义性问题。如代码九中，不能用g.a的方式访问a，因为编译器不知道你要访问的是S1中的还是S2中的，所以需要你使用g.类名::a的方式访问。如何解决？

            两种办法：1.就是上段的g.类名::a的方式访问。2.让顶层基类中的成员只有一份就可以了。这就引出了虚拟继承。

      (3)普通虚拟继承(超重要)

            一定要先理解普通虚拟继承，然后才能理解菱形虚拟继承。

        [1]使用方法

            class 子类名 : virtual 限定符 父类名{}

            代码十：这里直接告诉大家，虚拟继承时，下述代码中s对象大小是12字节，普通继承时大小是8字节。虚拟继承比普通继承多了四个字节。

    1. //代码十
    2. #include "iostream"
    3. using namespace std;
    4.  
    5. class B {
    6. public:
    7. 	int a;
    8. };
    9. class S :virtual public B {
    10. public:
    11. 	int b;
    12. };
    13.  
    14. int main() {
    15. 	S s;
    16. 	s.a = 7;
    17. 	s.b = 9;
    18. 	cout << sizeof(s);
    19. }

             这是虚拟继承的粗略对象模型：

            虚拟继承中，子类新增在最上面，顶层基类元素在最下面，且只有一份。

        [2]对象模型分析       

            上文中提到了编译器如果觉得没有用就不会生成默认构造函数，当代码十是普通继承时就不会生成，大家可以进入汇编看一下。但在虚拟继承中编译器自动生成了，为什么？

            因为编译器需要给多出来的4字节赋值。因为用户并无法给这四个字节赋值，所以如果类中没有定义构造函数，编译器必须生成。类中定义了构造函数，编译器就会修改它，在内部增加给4字节赋值的代码。

            那么那4字节是干什么的？那4字节指向一块空间，那块空间存放的是顶层基类中的元素位置离虚基表指针所在的位置相差多少字节。我们把这个记录距离长短的量叫做偏移量。那块空间叫做偏移量表格或者虚基表，那4个字节叫做虚基表指针。表格的第一项总是 00 00 00 00，这是代表虚基表指针离它自己的偏移量，自然是0。

            代码十的对象模型和详细内存布局：配合文字讲解一起看图，文字比较多，请耐心看完。

            虚拟继承的对象模型是：子类新增在最上面，最下面是顶层基类中的元素，并且顶层基类中的元素只有一份。

            对象的前四个字节是虚基表指针，指向一块空间，这块空间保存的是顶层基类中的元素和对象首地址相差多少字节，第一项是虚基表指针的位置离它自己相差多少字节，那当然是0。第二项存的是a变量离虚基表指针所在的位置相差8字节，可以看一下对象模型，正好差8个。

            这里再看一下汇编指令，配合着上端叙述一起理解。eax中存的就是对象前四个字节，eax+4不就是虚基表指针往后再移动四个字节吗，那这就移动到a的偏移量的位置了，然后用ecx保存a的偏移量，s[ecx]指的是，虚基表指针所在的位置往后移动ecx个字节，那就是移动8个字节，不就到a的位置了吗，然后再把7赋值给a。

      (4)菱形虚拟继承

        [1]使用方法

            两个父类虚拟继承顶层基类，子类普通多继承两个父类，示意图如下：

            代码十一：这里 看一下如何使用：

    1. //代码十一
    2. #include "iostream"
    3. using namespace std;
    4.  
    5. class B {
    6. public:
    7. 	int a;
    8. };
    9. class S1 :virtual public B {
    10. public:
    11. 	int b;
    12. };
    13. class S2 :virtual public B {
    14. public:
    15. 	int c;
    16. };
    17. class G :public S1, public S2 {
    18. public:
    19. 	int d;
    20. };
    21.  
    22. int main() {
    23. 	G g;
    24. 	g.a = 1;
    25. 	g.b = 2;
    26. 	g.c = 3;
    27. 	g.d = 4;
    28. }

        [2]对象模型验证

            这里来看一下菱形虚拟继承的对象模型：本文最复杂的图，没有之一！

            咱们一点一点分析：首先根据继承顺序，对象模型中依次是：S1的虚基表指针，S1的b，S2的虚基表指针，S2的c，子类新增的d，最后是顶层基类的a。这一点在内存1中可以体现出来，注意看里面的值。

            再来看一下S1的虚基表，第一项依旧是0，第二项是小端模式的16进制的14，也就是10进制的20，代表a离S1的虚基表指针的位置距离是20字节，看一下对象模型发现没错。

            再看S2的虚基表，第二项是10进制的12，代表a离S2的虚基表指针的位置距离是12个字节，看对象模型，也没有错。

        [3]总结 

            顶层基类中不止成员变量可以被虚拟继承，成员函数也可以。

             菱形虚拟继承可以解决菱形继承的二义性问题，但一般还是不要使用，因为太过复杂。

    5.继承的总结

            1.尽量不要使用多继承，因为比较容易出错。

            2.尽量多使用对象与对象之间的组合，少使用继承，因为对象的组合耦合度更低。

  • 相关阅读:
    java调用python文件的几种方式【超细讲解！】
    Python学习六（进程）
    MYSQL数据库管理与创建
    冠达管理：有色金属迎顺周期行情 板块估值降至历史低位
    【开源】嵌入式微服务框架MAES
    PostGIS学习教程七：关于几何图形的练习
    用户忠诚度：小程序积分商城的用户保持方法
    java 泛型返回
    自然语言处理技术之词向量：GloVe单词表示的全局向量（glove.840B.300d、glove.6B）
    K8S集群master节点打污点：可让master节点参与pod调度
  • 原文地址：https://blog.csdn.net/weixin_57761086/article/details/126603704