• C++ 学习（13）类和对象 - 继承、继承方式、对象模型、构造与析构顺序、继承同名成员、多继承、菱形继承

    继承是面向对象的特性之一，可减少重复代码。

    1、继承的基本语法

    C++ 继承基本语法

    语法： class 子类: 继承方式 父类

    父类也称作基类，子类也称作派生类

    派生类（子类）成员包含两大部分：

    一类是从基类（父类）继承过来的，一类是自己增加的成员。从基类继承过来的表现其共性，而新增的成员体现其个性。 

    1. #include 
    2. using namespace std;
    3.  
    4. //基类（父类）
    5. class Base
    6. {
    7. public:
    8. 	void printBase()
    9. 	{
    10. 		cout << "父类成员函数" << endl;
    11. 	}
    12. };
    13.  
    14. //派生类（子类）
    15. class Sub : public Base
    16. {
    17. public:	
    18. 	void printSub()
    19. 	{
    20. 		cout << "子类成员函数" << endl;
    21. 	}
    22. };
    23.  
    24. int main()
    25. {
    26. 	//类和对象 - 继承 - 基本语法
    27. 	Sub s1;
    28. 	s1.printSub();
    29. 	s1.printBase();
    30.  
    31. 	system("pause");
    32.  
    33. 	return 0;
    34. }

     输出结果

    子类成员函数
    父类成员函数

    Go语言 继承

    Go语言中没有class，继承的实现是通过在struct结构体内置匿名成员来实现的。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. //基类（父类）
    6. type Base struct {
    7. }
    8.  
    9. func (base *Base) printBase() {
    10. 	fmt.Println("父类成员函数")
    11. }
    12.  
    13. //派生类（子类）
    14. type Sub struct {
    15. 	Base //内置匿名父类结构体
    16. }
    17.  
    18. func (sub *Sub) printSub() {
    19. 	fmt.Println("子类成员函数")
    20. }
    21.  
    22. func main() {
    23. 	sub := Sub{}
    24. 	sub.printSub()
    25. 	sub.printBase()
    26. }

    输出结果

    子类成员函数
    父类成员函数

    2、继承方式

    C++ 继承方式

     三种继承方式：

    • public 公共继承：子类继承父类成员时，不能访问父类私有成员，父类中public成员继承后还是public，父类中protected成员继承后还是protected
    • protected 保护继承：子类继承父类成员时，不能访问父类私有成员，父类中public成员继承后变成protected，父类中protected成员继承后还是protected
    • private 私有继承：子类继承父类成员时，不能访问父类私有成员，父类中public成员与protected成员继承后变成private成员

     （1）公共继承（public）

    1. #include 
    2. using namespace std;
    3.  
    4. class Base
    5. {
    6. public:
    7. 	int a;
    8. protected:
    9. 	int b;
    10. private:
    11. 	int c;
    12. };
    13.  
    14. //公有继承
    15. class Sub : public Base
    16. {
    17. public:
    18. 	void setVal()
    19. 	{
    20. 		a = 1;
    21. 		b = 2;
    22. 		//c = 3; //子类中不能访问父类的私有成员，报错：成员Base::c不可访问
    23. 	}
    24. };
    25.  
    26. int main()
    27. {
    28. 	//类和对象 - 继承方式 - 公有继承
    29. 	//public 公共继承：子类继承父类成员时，不能访问父类私有成员，父类中public成员继承后还是public，父类中protected成员继承后还是protected
    30. 	Sub s1;
    31. 	s1.a;
    32. 	//s1.b; //子类对象不能访问父类的保护成员，报错：成员Base::b不可访问
    33.  
    34. 	system("pause");
    35.  
    36. 	return 0;
    37. }

     （2）保护继承（protected）

    1. #include 
    2. using namespace std;
    3.  
    4. class Base
    5. {
    6. public:
    7. 	int a;
    8. protected:
    9. 	int b;
    10. private:
    11. 	int c;
    12. };
    13.  
    14. //保护继承
    15. class Sub : protected Base
    16. {
    17. public:
    18. 	void setVal()
    19. 	{
    20. 		a = 1; //在子类中，已变为保护成员，子类能够访问，子类对象不能访问
    21. 		b = 2;
    22. 		//c = 3; //子类中不能访问父类的私有成员，报错：成员Base::c不可访问
    23. 	}
    24. };
    25.  
    26.  
    27. //继承子类
    28. class Grand : public Sub
    29. {
    30. public:
    31. 	void setVal()
    32. 	{
    33. 		a = 3; //子类中可以访问父类的保护成员
    34. 		b = 5; //子类中可以访问父类的保护成员
    35. 	}
    36. };
    37.  
    38. int main()
    39. {
    40. 	//类和对象 - 继承方式 - 保护继承
    41. 	//protected 保护继承：子类继承父类成员时，不能访问父类私有成员，父类中public成员继承后变成protected，父类中protected成员继承后还是protected
    42. 	Sub s1;
    43. 	//s1.a; //保护继承后，子类对象不能访问父类成员中的公有成员，因为在子类继承中已变成protected，报错：成员Base::a不可访问
    44. 	//s1.b; //对象不能访问保护成员，报错：成员Base::b不可访问
    45.  
    46. 	Grand g1;
    47. 	//g1.a; //对象不能访问保护成员，报错：成员Base::b不可访问
    48. 	//g1.b; //对象不能访问保护成员，报错：成员Base::b不可访问
    49.  
    50. 	system("pause");
    51.  
    52. 	return 0;
    53. }

     （3）私有继承（private）

    1. #include 
    2. using namespace std;
    3.  
    4. class Base
    5. {
    6. public:
    7. 	int a;
    8. protected:
    9. 	int b;
    10. private:
    11. 	int c;
    12. };
    13.  
    14. //私有继承
    15. class Sub : private Base
    16. {
    17. public:
    18. 	void setVal()
    19. 	{
    20. 		a = 1; //在子类中，已变为私有成员，不能子类访问
    21. 		b = 2; //在子类中，已变为私有成员，不能子类访问
    22. 		//c = 3; //子类中不能访问父类的私有成员，报错：成员Base::c不可访问
    23. 	}
    24. };
    25.  
    26. //继承子类
    27. class Grand : public Sub
    28. {
    29. public:
    30. 	void setVal()
    31. 	{
    32. 		//a = 1; //子类中不能访问父类的私有成员，报错：成员Base::a不可访问
    33. 	}
    34. };
    35.  
    36. int main()
    37. {
    38. 	//类和对象 - 继承方式 - 私有继承
    39. 	//private 私有继承：子类继承父类成员时，不能访问父类私有成员，父类中public成员与protected成员继承后变成private成员
    40. 	Sub s1;
    41. 	//s1.a; //私有继承后，子类对象不能访问父类成员中的公有成员，因为在子类继承中已变成private，报错：成员Base::a不可访问
    42. 	//s1.b; //私有继承后，子类对象不能访问父类的保护成员，因为在子类继承中已变成private，报错：成员Base::b不可访问
    43.  
    44. 	system("pause");
    45.  
    46. 	return 0;
    47. }

    Go语言 继承方式

    Go语言中，没有像C++有public、protected、private的修饰访问权限，是通过首字母大小写来确定访问权限的，方法名、常量、变量名、结构体名等，同包内首字母大小写都可访问（理解为公有的），不同包时只有首字母大写才能被访问（理解为公有的），不同包内首字母小写不能被访问（理解为私有的）。

    在base包中定义一个父类结构体

    1. package base
    2.  
    3. //基类（父类） - 结构体名首字母大写
    4. type Base2 struct {
    5. 	Name string //首字母大写
    6. 	age int	 	//首字母小写
    7. }
    8.  
    9. //结构体名首字母小写
    10. type base3 struct {
    11. 	Name string //首字母大写
    12. 	age int	 	//首字母小写
    13. }

    在main包中继承base包中的父类结构体

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	base "testProject/CPlus/2-类/继承方式"
    6. )
    7.  
    8. //基类（父类）
    9. type Base struct {
    10. 	Name string //
    11. 	age int	 //
    12. }
    13.  
    14. //派生类（子类） - 继承同包中的父类
    15. type Sub struct {
    16. 	Base 		//内置匿名父类结构体（同包内）
    17. }
    18.  
    19. //派生类（子类） - 继承不同包中的父类 - 结构体名首字母大写
    20. type Sub2 struct {
    21. 	base.Base2	//内置匿名父类结构体（不同包）
    22. }
    23.  
    24. //派生类（子类） - 继承不同包中的父类 - 结构体名首字母小写
    25. type Sub3 struct {
    26. 	// base.base3	//不能访问不同包下首字母小写的结构体，error: Unexported type "base3" usage
    27. }
    28.  
    29. func main() {
    30. 	fmt.Println("---- 子类继承同包中的父类 ----")
    31.  
    32. 	sub := Sub{}
    33. 	sub.Name = "Hello"
    34. 	sub.age = 2
    35. 	fmt.Printf("Name = %s, age = %d\n", sub.Name, sub.age)
    36.  
    37. 	fmt.Println("---- 子类继承不同包中的父类 ----")
    38.  
    39. 	sub2 := Sub2{}
    40. 	sub2.Name = "World"
    41. 	//sub2.age = 23 //error: Unexported field "age" usage
    42. 	fmt.Printf("Name = %s, 不能访问小写字母开头的属性 age\n", sub2.Name)
    43. }

    ---- 子类继承同包中的父类 ----
    Name = Hello, age = 2
    ---- 子类继承不同包中的父类 ----
    Name = World, 不能访问小写字母开头的属性 age

    3、对象模型

    C++ 内存对象模型

    1. #include 
    2. using namespace std;
    3.  
    4. class Base
    5. {
    6. public:
    7. 	int a;
    8. protected:
    9. 	int b;
    10. private:
    11. 	int c;
    12. };
    13.  
    14. class Sub : public Base
    15. {
    16. public:
    17. 	int d;
    18. };
    19.  
    20. int main()
    21. {
    22. 	//类和对象 - 继承 - 对象模型
    23. 	cout << "子类占用空间大小：" << sizeof(Sub) << endl;
    24.  
    25. 	system("pause");
    26.  
    27. 	return 0;
    28. }

    输出结果

    子类占用空间大小：16

    查看内存对象模型

    命令: cl /d1 reportSingleClassLayout类名 "文件名"

    reportSingleClassLayout后面连接的是要查看的类名

    注意：/d1 此处是数字1，不是小写字母l

    F:\CPlus\>cl /d1 reportSingleClassLayoutSub "rs.cpp"
    用于 x86 的 Microsoft (R) C/C++ 优化编译器 19.32.31332 版
    版权所有(C) Microsoft Corporation。保留所有权利。

    rs.cpp

    class Sub       size(16):
            +---
     0      | +--- (base class Base)
     0      | | a
     4      | | b
     8      | | c
            | +---
    12      | d
            +---
    E:\Program\VisualStudio\VC\Tools\MSVC\14.32.31326\include\ostream(301): warning C4530: 使用了 C++ 异常处理程序，但未启用展开语义。请指定 /EHsc
    E:\Program\VisualStudio\VC\Tools\MSVC\14.32.31326\include\ostream(294): note: 在编译 类 模板 成员函数“std::basic_ostream> &std::basic_ostream>::operator <<(unsigned int)”时
    rs.cpp(23): note: 查看对正在编译的函数 模板 实例化“std::basic_ostream> &std::basic_ostream>::operator <<(unsigned int)”的引用
    rs.cpp(23): note: 查看对正在编译的 类 模板 实例化“std::basic_ostream>”的引用
    Microsoft (R) Incremental Linker Version 14.32.31332.0
    Copyright (C) Microsoft Corporation.  All rights reserved.

    /out:rs.exe
    rs.obj

    Go语言 子类占用空间大小

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"unsafe"
    6. )
    7.  
    8. //基类（父类）
    9. type Base struct {
    10. 	a int32
    11. 	b int32
    12. 	c int32
    13. }
    14.  
    15. //派生类（子类）
    16. type Sub struct {
    17. 	Base
    18. 	d int32
    19. }
    20.  
    21. func (s *Sub) print() {
    22. 	fmt.Println(s)
    23. }
    24.  
    25. func main() {
    26. 	sub := Sub{}
    27. 	fmt.Printf("子类占用空间大小 : %d\n", unsafe.Sizeof(sub))
    28. }

     输出结果

    子类占用空间大小 : 16

    4、C++ 继承中构造和析构顺序

    • 构造函数顺序：父类先构造，子类再构造
    • 析构函数顺序：子类先析构，父类再析构；与构造函数顺序相反
    1. #include 
    2. using namespace std;
    3.  
    4. class Base
    5. {
    6. public:
    7. 	Base()
    8. 	{
    9. 		cout << "父类构造函数" << endl;
    10. 	}
    11.  
    12. 	~Base()
    13. 	{
    14. 		cout << "父类析构函数" << endl;
    15. 	}
    16. };
    17.  
    18. class Sub : public Base
    19. {
    20. public:
    21. 	Sub()
    22. 	{
    23. 		cout << "子类构造函数~" << endl;
    24. 	}
    25.  
    26. 	~Sub()
    27. 	{
    28. 		cout << "子类析构函数~" << endl;
    29. 	}
    30. };
    31.  
    32. void test()
    33. {
    34. 	Sub s1;
    35. }
    36.  
    37. int main()
    38. {
    39. 	//类和对象 - 继承 - 构造函数与析构函数顺序
    40. 	test();
    41.  
    42. 	system("pause");
    43.  
    44. 	return 0;
    45. }

    父类构造函数
    子类构造函数~
    子类析构函数~
    父类析构函数

    5、继承同名成员处理方式

    子类与父类出现同名的成员时：

    • 访问子类同名成员，直接访问即可
    • 访问父类同名成员，需要加作用域

    C++ 继承同名成员处理方式

    子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有的同名成员函数（成员函数重载时会有多个同名函数），如果子类想访问父类中被隐藏掉的同名成员函数，需要加作用域。 

    1. #include 
    2. using namespace std;
    3.  
    4. class Base
    5. {
    6. public:
    7. 	int a;
    8. 	Base() {
    9. 		a = 3;
    10. 	}
    11.  
    12. 	void f1()
    13. 	{
    14. 		cout << "父类中同名成员函数f1()" << endl;
    15. 	}
    16.  
    17. 	void f1(int _a)
    18. 	{
    19. 		cout << "父类中同名成员函数f1(int), 参数值 = " << _a << endl;
    20. 	}
    21. };
    22.  
    23. class Sub : public Base
    24. {
    25. public:
    26. 	int a; //成员属性与父类同名
    27. 	Sub()
    28. 	{
    29. 		a = 5;
    30. 	}
    31.  
    32. 	void f1() //成员函数与父类同名
    33. 	{
    34. 		cout << "子类中同名成员函数f1()" << endl;
    35. 	}
    36.  
    37. };
    38.  
    39. int main()
    40. {
    41. 	//类和对象 - 继承 - 继承同名成员处理方式
    42. 	/*
    43. 		访问子类同名成员，直接访问即可
    44. 		访问父类同名成员，需要加作用域
    45. 	*/
    46. 	Sub s1;
    47. 	cout << "访问子类同名成员属性， a = " << s1.a << endl;
    48. 	cout << "访问父类同名成员属性， a = " << s1.Base::a << endl;
    49.  
    50. 	s1.f1();
    51. 	s1.Base::f1();
    52. 	s1.Base::f1(8);
    53.  
    54. 	system("pause");
    55.  
    56. 	return 0;
    57. }

    输出结果 

    访问子类同名成员属性， a = 5
    访问父类同名成员属性， a = 3
    子类中同名成员函数f1()
    父类中同名成员函数f1()
    父类中同名成员函数f1(int), 参数值 = 8

    Go语言 继承同名成员处理方式 

    注：Go语言中没有重载函数

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6.  
    7. //基类（父类）
    8. type Base struct {
    9. 	a int
    10. }
    11.  
    12. func (base *Base) print() {
    13. 	fmt.Println("父类同名函数中，父类同名属性 a = ", base.a)
    14. }
    15.  
    16. //派生类（子类）
    17. type Sub struct {
    18. 	Base 	//内置匿名父类结构体
    19. 	a int  	//成员属性与父类同名
    20. }
    21.  
    22. //成员函数与父类同名
    23. func (sub *Sub) print() {
    24. 	fmt.Println("子类同名函数中，子类同名属性 a = ", sub.a)
    25. }
    26.  
    27. func main() {
    28. 	fmt.Println("---- 子类成员与父类同名 ----")
    29.  
    30. 	sub := Sub{}
    31. 	sub.a = 3
    32. 	sub.print()
    33. 	sub.Base.a = 5		//访问父类成员属性
    34. 	sub.Base.print()	//访问父类成员函数
    35. }

    输出结果

     ---- 子类成员与父类同名 ----
    子类同名函数中，子类同名属性 a =  3
    父类同名函数中，父类同名属性 a =  5

    6、继承中静态成员处理方式

    C++ 继承中静态成员

    继承中同名的静态成员在子类对象中的访问方式，与非静态成员访问方式一样：

    • 访问子类同名成员，直接访问即可
    • 访问父类同名成员，需要加作用域

    可通过对象访问，也可通过类名访问

    1. #include 
    2. using namespace std;
    3.  
    4. class Base
    5. {
    6. public:
    7. 	static int a;
    8.  
    9. 	static void f1()
    10. 	{
    11. 		cout << "父类中同名成员函数f1()" << endl;
    12. 	}
    13.  
    14. 	static void f1(int _a)
    15. 	{
    16. 		cout << "父类中同名成员函数f1(int)，参数值 = " << _a << endl;
    17. 	}
    18. };
    19. int Base::a = 5;
    20.  
    21. class Sub : public Base
    22. {
    23. public:
    24. 	static int a; //成员属性与父类同名
    25.  
    26. 	static void f1() //成员函数与父类同名
    27. 	{
    28. 		cout << "子类中同名成员函数f1()" << endl;
    29. 	}
    30. };
    31.  
    32. int Sub::a = 3;
    33.  
    34. int main()
    35. {
    36. 	//类和对象 - 继承 - 继承同名成员处理方式 - 静态成员
    37. 	/*
    38. 		访问子类同名成员，直接访问即可
    39. 		访问父类同名成员，需要加作用域
    40. 	*/
    41.  
    42. 	Sub s1;
    43. 	cout << "--- 通过对象访问 ---" << endl;
    44. 	cout << "访问子类同名成员属性， a = " << s1.a << endl;
    45. 	cout << "访问父类同名成员属性， a = " << s1.Base::a << endl;
    46. 	s1.f1();
    47. 	s1.Base::f1();
    48. 	s1.Base::f1(8);
    49.  
    50. 	cout << endl << "--- 通过类名访问 ---" << endl;
    51. 	cout << "访问子类同名成员属性， a = " << Sub::a << endl;
    52. 	cout << "访问父类同名成员属性， a = " << Sub::Base::a << endl;
    53. 	Sub::f1();
    54. 	Sub::Base::f1();
    55. 	Sub::Base::f1(12);
    56.  
    57. 	system("pause");
    58.  
    59. 	return 0;
    60. }

    输出结果

    --- 通过对象访问 ---
    访问子类同名成员属性， a = 3
    访问父类同名成员属性， a = 5
    子类中同名成员函数f1()
    父类中同名成员函数f1()
    父类中同名成员函数f1(int)，参数值 = 8

    --- 通过类名访问 ---
    访问子类同名成员属性， a = 3
    访问父类同名成员属性， a = 5
    子类中同名成员函数f1()
    父类中同名成员函数f1()
    父类中同名成员函数f1(int)，参数值 = 12

    Go语言中没有静态成员

    7、多继承

    C++ 多继承

    C++ 允许一个类继承多个类，多继承可能会引发父类中有同名成员出现，需要加作用域区分。

    语法： class 子类: 继承方式 父类1,  继承方式 父类2 ......

    1. #include 
    2. using namespace std;
    3.  
    4. //父类
    5. class Base1
    6. {
    7. public:
    8. 	int a;
    9. 	int b;
    10.  
    11. 	Base1()
    12. 	{
    13. 		a = 11;
    14. 		b = 12;
    15. 	}
    16. };
    17.  
    18. //父类
    19. class Base2
    20. {
    21. public:
    22. 	int a;  //同名成员属性
    23. 	int c;
    24.  
    25. 	Base2()
    26. 	{
    27. 		a = 21;
    28. 		c = 22;
    29. 	}
    30. };
    31.  
    32. //子类 - 多继承
    33. class Sub : public Base1, public Base2
    34. {
    35. public:
    36. 	int d;
    37. 	int e;
    38.  
    39. 	Sub()
    40. 	{
    41. 		d = 31;
    42. 		e = 32;
    43. 	}
    44. };
    45.  
    46. int main()
    47. {
    48. 	//类和对象 - 继承 - 多继承
    49.  
    50. 	Sub s1;
    51. 	cout << "访问子类自己的成员属性： d = " << s1.d << endl;
    52. 	cout << "访问父类Base1的成员属性： b = " << s1.Base1::b << endl;
    53. 	cout << "访问父类Base2的成员属性： c = " << s1.Base2::c << endl;
    54. 	cout << "访问父类Base1的同名成员属性： a = " << s1.Base1::a << endl;
    55. 	cout << "访问父类Base2的同名成员属性： a = " << s1.Base2::a << endl;
    56.  
    57. 	system("pause");
    58.  
    59. 	return 0;
    60. }

    输出结果

    访问子类自己的成员属性： d = 31
    访问父类Base1的成员属性： b = 12
    访问父类Base2的成员属性： c = 22
    访问父类Base1的同名成员属性： a = 11
    访问父类Base2的同名成员属性： a = 21

    Go语言多继承

    Go语言可以通过匿名组合方式实现多继承（组合继承）。

    1. package main
    2.  
    3. //基类（父类）
    4. type Base1 struct {
    5. 	a int
    6. 	b int
    7. }
    8.  
    9. //基类（父类）
    10. type Base2 struct {
    11. 	a int 	//同名成员属性
    12. 	c int
    13. }
    14.  
    15. //派生类（子类）
    16. type Sub struct {
    17. 	Base1 	//内置匿名父类结构体
    18. 	Base2
    19. 	d int
    20. }
    21.  
    22. func main() {
    23. 	sub := Sub{}
    24. 	sub.d = 31	//访问子类自己的成员属性
    25. 	sub.b = 12  //访问父类Base1的成员属性
    26. 	sub.c = 22	//访问父类Base2的成员属性
    27. 	sub.Base1.a = 11 //访问父类Base1的同名成员属性
    28. 	sub.Base2.a = 21 //访问父类Base2的同名成员属性
    29. }

    8、菱形继承

    两个派生类继承同一个基类，又有某类同时继承了两个派生类，这种继承被称为菱形继承，或钻石继承。如下图所示，像个菱形一样的继承：

    举个栗子，如下图所示：

    C++ 菱形继承

    （1）菱形继承

    1. #include 
    2. using namespace std;
    3.  
    4. //基类 - 动物
    5. class Animal
    6. {
    7. public:
    8. 	int age;
    9. };
    10.  
    11. //派生类 - 羊 （继承动物类）
    12. class Sheep : public Animal
    13. {
    14.  
    15. };
    16.  
    17. //派生类 - 骆驼 （继承动物类）
    18. class Camel : public Animal
    19. {
    20.  
    21. };
    22.  
    23. //派生类 - 羊驼 （继承羊类 与 骆驼类）
    24. class Alpaca : public Sheep, public Camel
    25. {
    26.  
    27. };
    28.  
    29. int main()
    30. {
    31. 	//类和对象 - 菱形继承
    32. 	Alpaca alpaca;
    33. 	alpaca.Sheep::age = 18;
    34. 	alpaca.Camel::age = 20;
    35.  
    36. 	//在菱形继承中，两个父类拥有相同的数据，需要加以作用域区分
    37. 	//在实际中，羊驼的年龄记录一个就够了，不需要两份数据，导致数据不一致，也导致资源浪费
    38. 	cout << "在父类Sheep中，羊驼的年龄 age = " << alpaca.Sheep::age << endl;
    39. 	cout << "在父类Camel中，羊驼的年龄 age = " << alpaca.Camel::age << endl;
    40.  
    41. 	system("pause");
    42.  
    43. 	return 0;
    44. }

    输出结果

    在父类Sheep中，羊驼的年龄 age = 18
    在父类Camel中，羊驼的年龄 age = 20

    （2）抛出问题

    在实际中，羊驼的年龄记录一个就够了，不需要两份数据，导致数据不一致，也导致资源浪费。

    查看内存对象模型命令：cl /d1 reportSingleClassLayoutAlpaca "文件名.cpp"

    （3）解决问题（virtual）

    利用虚继承解决菱形继承问题。

    虚继承：在派生类前加上关键字 virtual 

    由于派生类为虚继承，所以基类变为虚基类

    1. #include 
    2. using namespace std;
    3.  
    4. //基类 - 动物 - 由于派生类为虚继承，所以基类变为虚基类
    5. class Animal
    6. {
    7. public:
    8. 	int age;
    9. };
    10.  
    11. //派生类 - 羊 （继承动物类） - 虚继承
    12. class Sheep : virtual public Animal
    13. {
    14.  
    15. };
    16.  
    17. //派生类 - 骆驼 （继承动物类） - 虚继承
    18. class Camel : virtual public Animal
    19. {
    20.  
    21. };
    22.  
    23. //派生类 - 羊驼 （继承羊类 与 骆驼类）
    24. class Alpaca : public Sheep, public Camel
    25. {
    26.  
    27. };
    28.  
    29. int main()
    30. {
    31. 	//类和对象 - 解决菱形继承问题 - 虚继承
    32. 	//菱形继承问题：在实际中，羊驼的年龄记录一个就够了，不需要两份数据，导致数据不一致，也导致资源浪费
    33. 	Alpaca alpaca;
    34. 	alpaca.Sheep::age = 18;
    35. 	alpaca.Camel::age = 20;
    36. 	
    37. 	cout << "在父类Sheep中，羊驼的年龄 age = " << alpaca.Sheep::age << endl;
    38. 	cout << "在父类Camel中，羊驼的年龄 age = " << alpaca.Camel::age << endl;
    39. 	cout << "在自己类Alpaca中，羊驼的年龄 age = " << alpaca.age << endl;
    40.  
    41. 	system("pause");
    42.  
    43. 	return 0;
    44. }

    输出结果

    在父类Sheep中，羊驼的年龄 age = 20
    在父类Camel中，羊驼的年龄 age = 20
    在自己类Alpaca中，羊驼的年龄 age = 20

    查看内存对象模型

    命令：  cl /d1 reportSingleClassLayoutAlpaca "文件名.cpp"

    vbptr 虚基类指针，v - virtual， b - base， ptr - pointer

    vbptr指向一个vbtable 虚基类表

    Go语言 菱形继承

    （1）菱形继承

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. //基类 - 动物
    6. type Animal struct {
    7. 	age int
    8. }
    9.  
    10. //派生类 - 羊 （继承动物类）
    11. type Sheep struct {
    12. 	Animal
    13. }
    14.  
    15. //派生类 - 骆驼 （继承动物类）
    16. type Camel struct {
    17. 	Animal
    18. }
    19.  
    20. //派生类 - 羊驼 （继承羊类 与 骆驼类）
    21. type Alpaca struct {
    22. 	Sheep
    23. 	Camel
    24. }
    25.  
    26. func main() {
    27. 	//类和对象 - 菱形继承
    28. 	alpaca := Alpaca{}
    29. 	alpaca.Sheep.age = 18
    30. 	alpaca.Camel.age = 20
    31.  
    32. 	fmt.Println("在父类Sheep中，羊驼的年龄 age = ", alpaca.Sheep.age)
    33. 	fmt.Println("在父类Camel中，羊驼的年龄 age = ", alpaca.Camel.age)
    34. }

     输出结果

    在父类Sheep中，羊驼的年龄 age = 18
    在父类Camel中，羊驼的年龄 age = 20

    （2）抛出问题

    同C++中抛出的问题一样：在实际中，羊驼的年龄记录一个就够了，不需要两份数据，导致数据不一致，也导致资源浪费。

    （3）解决问题（interface）

    Go语言中没有virtual来表示虚继承，可以通过 interface + struct 来实现虚基类的用法，需要实现interface中定义的方法。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. //接囗（虚基类） - 动物
    6. type IAnimal interface
    7. {
    8. 	setAge(age int)
    9. 	getAge() int
    10. }
    11.  
    12. //接囗实现 - 动物
    13. type AnimalImpl struct {
    14. 	age int
    15. }
    16.  
    17. func (m *AnimalImpl) setAge(age int) {
    18. 	m.age = age
    19. }
    20. func (m *AnimalImpl) getAge() int {
    21. 	return m.age
    22. }
    23.  
    24. //派生类 - 羊 （继承接囗）
    25. type Sheep struct {
    26. 	IAnimal
    27. }
    28.  
    29. //派生类 - 骆驼 （继承接囗）
    30. type Camel struct {
    31. 	IAnimal
    32. }
    33.  
    34. //派生类 - 羊驼 （继承羊类 与 骆驼类）
    35. type Alpaca struct {
    36. 	Sheep
    37. 	Camel
    38. }
    39.  
    40. func main() {
    41. 	//实现IAnimal接囗动物变量
    42. 	var animalImpl = AnimalImpl{}
    43.  
    44. 	//羊驼变量
    45. 	var alpaca = Alpaca{
    46. 		Sheep{&animalImpl},
    47. 		Camel{&animalImpl},
    48. 	}
    49.  
    50. 	alpaca.Sheep.setAge(18)
    51. 	alpaca.Camel.setAge(20)
    52.  
    53. 	fmt.Println("在父类Sheep中，羊驼的年龄 age = ", alpaca.Sheep.getAge())
    54. 	fmt.Println("在父类Camel中，羊驼的年龄 age = ", alpaca.Camel.getAge())
    55. }

    输出结果 

    在父类Sheep中，羊驼的年龄 age =  20
    在父类Camel中，羊驼的年龄 age =  20

  • 相关阅读:
    乱七八糟：程序员（媛）请保护好自己
    【软件工程】金管局计算机岗位——软件测试的分类（⭐⭐⭐⭐）
    AlibabaCloud微服务：Linux 部署 Nacos 服务治理
    docker运行镜像、docker删除镜像、docker运行容器、docker退出当前容器、docker关闭容器、docker重新回到后台运行的容器命令
    pgsql查询分组中某个字段最大或者最小的一条数据
    电压提前/滞后电路 —— 电赛综测备赛
    聊聊自制的探索大全扑克牌
    密码学系列之:PKI的证书格式表示X.509
    实验七 循环神经网络（2）梯度爆炸实验
    基于动态邻域的切换粒子群优化算法
  • 原文地址：https://blog.csdn.net/ling1998/article/details/125981323