• 【C++】-- 继承

    目录

    一、什么是继承

    1.继承定义 

    2.继承基类成员访问方式

    二、基类和派生类互相赋值转换

    1.赋值规则

    2.切片

    （1）子类对象赋值给父类对象

    （2）子类对象赋值给父类指针

    （3）子类对象赋值给父类引用

    三、继承中的作用域

    1.父类和子类都有独立的作用域

    2.隐藏

    3.如果是成员函数的隐藏，只需要函数名相同就构成隐藏

    4.继承中最好不要定义同名成员

    四、子类的默认成员函数

    1.规则①  

    2.规则②

    3.规则③

    4.规则④

    五、继承和友元

    六、继承和静态成员

    七、菱形继承

     1.单继承

    2.多继承

    3.菱形继承

    八、菱形虚拟继承

    1.虚继承

    2.虚继承的解决数据冗余和二义性的原理

    （1）普通继承 

    （2）虚继承

    九.继承和组合

    一、什么是继承

    1.继承定义 

    继承机制是面向对象程序设计使代码可以复用的最重要的手段，该机制自动地为一个类提供来自另一个类的操作和数据结构。只需要在新类中定义已有的类中没有的成分来建立一个新类。继承是类设计层次的复用。

    继承包括成员变量和成员函数。

    如下所示，Animal类的成员变量有age，成员函数有eat( )和sleep( )。Dog类的成员变量有legs，继承了Animal的age成员变量、成员函数eat( )和sleep( )，并且还定义了新的成员变量legs和新的成员函数bark( )，因此Dog类有2个成员变量：age和legs，3个成员函数：eat( )、sleep( )、bark( )。

    Animal叫做父类，也叫做基类。Dog叫做子类，也叫作派生类。

     转化成代码：

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #include
    3. using namespace std;
    4. class Animal
    5. {
    6. public:
    7. 	void eat()
    8. 	{}
    9.  
    10. 	void sleep()
    11. 	{}
    12.  
    13. private:
    14. 	int _age = 1;
    15. };
    16.  
    17.  
    18. class Dog :public Animal
    19. {
    20. public:
    21. 	void bark()
    22. 	{}
    23.  
    24. public:
    25. 	int _legs = 4;
    26. };
    27.  
    28. int main()
    29. {
    30. 	Animal a;
    31. 	Dog d;
    32.  
    33. 	return 0;
    34. }

    F10监视，可以看到对象a的成员变量只有一个，age。对象d的成员变量有两个，一个是继承自Animal的age，一个是Dog类自己定义的成员变量legs:

    2.继承基类成员访问方式

    父类有3种访问方式：public、protected、private，子类继承父类也有3种继承方式：public、protected、private。组合起来一共有9种：

     总结：

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

    关于什么叫做不可见：

    假如将父类成员改为private，那么子类继承了父类的私有成员，内存上，子类对象有这个成员，但是语法上不允许访问：

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #include
    3. using namespace std;
    4. class Animal
    5. {
    6. public:
    7. 	void eat()
    8. 	{}
    9.  
    10. 	void sleep()
    11. 	{}
    12.  
    13. private://访问方式改为private
    14. 	int _age = 1;
    15. };
    16.  
    17.  
    18. class Dog :public Animal
    19. {
    20. public:
    21. 	void bark()
    22. 	{}
    23.  
    24. 	void func()
    25. 	{
    26. 		//cout << _age << endl;//语法上不可以访问，但是内存上，子类对象有父类的私有成员
    27. 	}
    28. public:
    29. 	int _legs = 4;
    30. };
    31.  
    32. int main()
    33. {
    34. 	Animal a;
    35. 	Dog d;
    36.  
    37. 	return 0;
    38. }

    F10监视：

    二、基类和派生类互相赋值转换

    1.赋值规则

    （1）派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。即把派生类中父类那部分切来赋值过去。（子可以给父）
    （2）基类对象不能赋值给派生类对象。（父不能给子）
    （3）基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的。

    2.切片

    （1）子类对象赋值给父类对象

    子可以赋值给父，但父不能赋值给子： 

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #include
    3. #include
    4. using namespace std;
    5.  
    6. class Person
    7. {
    8. public:
    9. 	string _name;
    10. 	string _sex;
    11. 	int _age;
    12. };
    13.  
    14. class Student:public Person
    15. {
    16. public:
    17. 	int _No;
    18. };
    19.  
    20. int main()
    21. {
    22.     //1.子类对象赋值给父类对象
    23.     //定义对象时，内置类型不处理，自定义类型会调用自己默认的构造函数
    24. 	Person p;
    25. 	Student s;
    26.     
    27.     s._name = "Delia";
    28.     s._sex = "女";
    29.     s._No = 21356;
    30.  
    31. 	p = s;//子可以给父
    32. 	//s = p;编译报错，父不能给子
    33. 	return 0;
    34. }

    F10监视： 像拷贝构造一样，把子类中父类那部分切片赋值给父类对象，也就是把子类成员依次赋值给父类对象：

     从string的buffer的地址可以看出，string调用了深拷贝，因为s和p的_name虽然内容都是"Delia"，但是两个Delia的地址不同：

     

    假如父类和子类有同名成员变量，那么切片赋值时，只会切割从父类继承的成员，即把父类的成员变量切过去，因为父类并不拥有子类的成员变量，因此切片后，父类的成员变量的值为父类的成员变量的值。如，父类和子类拥有同名成员变量_No：

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #include
    3. #include
    4. using namespace std;
    5.  
    6. class Person
    7. {
    8. public:
    9. 	string _name;
    10. 	string _sex;
    11. 	int _age;
    12. 	int _No = 999;
    13. };
    14.  
    15. class Student :public Person
    16. {
    17. public:
    18. 	int _No;
    19. };
    20.  
    21. int main()
    22. {
    23. 	//1.子类对象赋值给父类对象
    24. 	//定义对象时，内置类型不处理，自定义类型会调用自己默认的构造函数
    25. 	Person p;
    26. 	Student s;
    27.  
    28. 	s._name = "Delia";
    29. 	s._sex = "女";
    30. 	s._No = 21356;
    31.  
    32. 	p = s;//子可以给父
    33. 	cout << "p._No : " << p._No << endl;
    34.  
    35. 	return 0;
    36. }

    （2）子类对象赋值给父类指针

    ① 子类对象可以赋值给父类指针

    1. int main()
    2. {
    3. 	//2.子类对象赋值给父类指针
    4. 	Person *p;
    5. 	Student s;
    6.  
    7. 	s._name = "Delia";
    8. 	s._sex = "女";
    9. 	s._No = 21356;
    10.  
    11. 	p = &s;
    12.  
    13. 	return 0;
    14. }

    F10-监视：发现子类对象s给父类指针p赋值成功，子类对象初始化了父类对象的一部分，_name和_sex，因此子类对象赋值给父类对象后，父类对象只能初始化子类对象赋值的成员，对于其他成员，如果是内置类型不处理，_age为随机值，自定义类型会调用它的默认构造函数：

    ② 若父类指针要赋值给子类指针，必须将父类指针强转为子类指针：

    1. int main()
    2. {
    3.  
    4. 	//父类指针赋值给子类指针
    5. 	Person p;//父类对象
    6. 	Student *s;//子类指针
    7. 	
    8. 	p._name = "Delia";
    9. 	p._sex = "女";
    10. 	p._age = 6;
    11.  
    12. 	Person* pp = &p;//父类指针
    13.  
    14. 	s = (Student*)pp;//将父类指针强转为子类型指针后，再赋值给子类型指针
    15.  
    16. 	return 0;
    17. }

    F10监视：父类指针成功赋值给子类指针： 

    ③ 指向父类对象的父类指针，强转为子类指针后赋值给子类指针可能会造成访问越界

    1. int main()
    2. {
    3. 	//指向父类对象的父类指针，强转为子类指针后赋值给子类指针可能会造成访问越界
    4. 	Person p;
    5. 	
    6. 	p._name = "Delia";
    7. 	p._sex = "女";
    8. 	p._age = 7;
    9. 	//s._No = 21530;
    10.  
    11. 	Person* pp = &p;
    12.  
    13. 	Student* ss = (Student*)pp;
    14. 	//ss->_No = 6;访问越界造成程序崩掉
    15.  
    16. 	return 0;
    17. }

     F10监视：发现赋值成功了

    （3）子类对象赋值给父类引用

    1. int main()
    2. {
    3.  
    4. 	//子类对象赋值给父类引用
    5. 	Student s;
    6. 	
    7.     s._name = "Delia";
    8. 	s._sex = "女";
    9. 	s._age = 7;
    10. 	s._No = 21369;
    11.  
    12. 	Person& rp = s;//子类对象赋值给父类引用
    13.  
    14. 	return 0;
    15. }

     F10监视：父类引用被成功赋值了：

    三、继承中的作用域

    1.父类和子类都有独立的作用域

     如下：子类中初始化的变量的值不受父类中初始化的变量的值的影响。

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #include
    3. using namespace std;
    4.  
    5. class Shape
    6. {
    7. public:
    8. 	void setWidth(float w)
    9. 	{
    10. 		_width = w;
    11. 	}
    12.  
    13. 	void setHeight(float h)
    14. 	{
    15. 		_height = h;
    16. 	}
    17.  
    18. 	void ShapePrintf()
    19. 	{
    20. 		cout << "Shape : _width" << ":" << _width << endl;
    21. 		cout << "Shape : _height" << ":" << _height << endl;
    22. 	}
    23.  
    24. public:
    25. 	float _width = 10;
    26. 	float _height = 10;
    27. };
    28.  
    29. class Rectangle : public Shape
    30. {
    31. public:
    32. 	float Area()
    33. 	{
    34. 		return _width * _height;
    35. 	}
    36.  
    37. 	void RectanglePrintf()
    38. 	{
    39. 		_width = 20;
    40. 		_height = 30;
    41. 		cout << "Rectangle : _width" << ":" << _width << endl;
    42. 		cout << "Rectangle : _height" << ":" << _height << endl;
    43. 	}
    44.  
    45. };
    46.  
    47. int main()
    48. {
    49. 	Shape s;
    50. 	s.ShapePrintf();
    51.  
    52. 	Rectangle r;
    53. 	r.RectanglePrintf();
    54.  
    55.     return 0;
    56. }

    父类的_width和_height是父类中初始化的值，子类的_width和_height是子类中初始化的值：

    2.隐藏

    子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 父类::父类成员 显式访问父类的同名成员）

    在父类和子类中定义同名成员_width： 

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #include
    3. using namespace std;
    4.  
    5. class Shape
    6. {
    7. public:
    8. 	void setWidth(float w)
    9. 	{
    10. 		_width = w;
    11. 	}
    12.  
    13. 	void setHeight(float h)
    14. 	{
    15. 		_height = h;
    16. 	}
    17.  
    18. 	void ShapePrintf()
    19. 	{
    20. 		cout << "Shape : _width" << ":" << _width << endl;
    21. 		cout << "Shape : _height" << ":" << _height << endl;
    22. 	}
    23.  
    24. public:
    25. 	float _width = 10;
    26. 	float _height = 10;
    27. };
    28.  
    29. class Rectangle : public Shape
    30. {
    31. public:
    32. 	float Area()
    33. 	{
    34. 		return _width * _height;
    35. 	}
    36.  
    37. 	void RectanglePrintf()
    38. 	{
    39. 		cout << "Rectangle : _width" << ":" << _width << endl;
    40. 		cout << "Rectangle : _height" << ":" << _height << endl;
    41. 	}
    42. public:
    43. 	float _width = 50;//子类重定义同名成员
    44. };
    45.  
    46. int main()
    47. {
    48. 	Shape s;
    49. 	s.ShapePrintf();
    50.  
    51. 	Rectangle r;
    52. 	r.RectanglePrintf();
    53.  
    54.     return 0;
    55.  
    56. }

     发现子类打印的_width的值是子类初始化的值，这是因为子类和父类的成员同名时，构成了隐藏，子类成员屏蔽了父类对同名成员的访问：

     那么子类对象r中到底有一个_width还是有两个_width呢？F10-监视：发现r中有两个_width，根据刚才的打印发现_width访问的是子类的_width 50。那么说明代码根据就近原则，在子类中优先访问了子类的同名成员。

     如果就想在子类中访问父类的同名成员呢？需要用::访问限定符指定访问的是父类的同名成员，即父类::父类成员

    将上述代码中RectanglePrintf()函数中的

            cout << "Rectangle : _width" << ":" << _width << endl;

    改为显式访问父类成员：

            cout << "Shape : _width" << ":" << Shape::_width << endl;

     这就打印了父类的同名成员：

    3.如果是成员函数的隐藏，只需要函数名相同就构成隐藏

    由于子类继承父类的所有成员，因此，子类对象可以直接访问父类的成员，那么子类对象r可以访问父类Shape类的成员setHeight()：

    1. int main()
    2. {
    3. 	Rectangle r;
    4. 	r.setHeight(100);
    5. 	cout << "r._height : " << r._height << endl;
    6. 	
    7. 	return 0;
    8. }

    访问成功：

     如果子类成员函数名和父类成员函数名相同，不管参数相不相同，都会构成隐藏，即子类成员屏蔽父类同名函数的访问，子类对象不可以访问父类的同名称成员函数：

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #include
    3. using namespace std;
    4.  
    5. class Shape
    6. {
    7. public:
    8. 	void setWidth(float w)
    9. 	{
    10. 		_width = w;
    11. 	}
    12.  
    13. 	void setHeight(float h)
    14. 	{
    15. 		_height = h;
    16. 	}
    17.  
    18. 	//和子类成员函数同名
    19. 	void printf()
    20. 	{
    21. 		cout << "Shape : _width" << ":" << _width << endl;
    22. 		cout << "Shape : _height" << ":" << _height << endl;
    23. 	}
    24.  
    25. public:
    26. 	float _width = 10;
    27. 	float _height = 10;
    28. };
    29.  
    30. class Rectangle : public Shape
    31. {
    32. public:
    33. 	float Area()
    34. 	{
    35. 		return _width * _height;
    36. 	}
    37.  
    38. 	//和父类成员函数同名,不论参数和父类同名函数的参数相不相同
    39. 	void printf(float width,float height)
    40. 	{
    41. 		cout << "Rectangle : _width" << ":" << width << endl;
    42. 		cout << "Rectangle : _height" << ":" << height << endl;
    43. 	}
    44.  
    45. public:
    46. 	float _width = 50;
    47. };
    48.  
    49. int main()
    50. {
    51. 	
    52. 	Rectangle r;
    53. 	r.printf();
    54. 	
    55. 	return 0;
    56. }

    r.printf()这一行会报错：

    这是因为，只要父类函数和子类函数同名，都会构成隐藏，不管参数相不相同。隐藏了父类同名函数之后，子类对象就不能访问父类同名函数了。

    4.继承中最好不要定义同名成员

    四、子类的默认成员函数

    以前学过类的默认成员函数，父类遵从类的默认成员函数规则，那么子类的默认成员函数如何生成呢？

    6个默认成员函数中，取地址操作符重载和const修饰的取地址操作符重载不常用，只需要看前4种即可。

    写上父类的默认成员函数：

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #include
    3. using namespace std;
    4.  
    5. class Shape
    6. {
    7. public:
    8. 	Shape(float width = 10,float height = 10)
    9. 		:_width(width)
    10. 		,_height(height)
    11. 	{
    12. 		cout << "Shape()" << endl;
    13. 	}
    14.  
    15. 	Shape(const Shape& s)
    16. 		:_width(s._width)
    17. 		,_height(s._height)
    18. 	{
    19. 		cout << "Shape(const Shape& s)" << endl;
    20. 	}
    21.  
    22. 	Shape& operator=(const Shape& p)
    23. 	{
    24. 		cout << "Shape& operator=(const Shape& p)" << endl;
    25. 		if (&p != this)
    26. 		{
    27. 			_width = p._width;
    28. 			_height = p._height;
    29. 		}
    30.  
    31. 		return *this;
    32. 	}
    33.  
    34. 	~Shape()
    35. 	{
    36. 		cout << "~Shape()" << endl;
    37. 	}
    38.  
    39. 	void setWidth(float w)
    40. 	{
    41. 		_width = w;
    42. 	}
    43.  
    44. 	void setHeight(float h)
    45. 	{
    46. 		_height = h;
    47. 	}
    48.  
    49. 	//和子类成员函数同名
    50. 	void ShapePrintf()
    51. 	{
    52. 		cout << "Shape : _width" << ":" << _width << endl;
    53. 		cout << "Shape : _height" << ":" << _height << endl;
    54. 	}
    55.  
    56. public:
    57. 	float _width;//声明成员变量时不给默认值
    58. 	float _height;//声明成员变量时不给默认值
    59. };
    60.  
    61. class Rectangle : public Shape
    62. {
    63. public:
    64. 	float Area()
    65. 	{
    66. 		return _width * _height;
    67. 	}
    68.  
    69. 	void RectanglePrintf(float width,float height)
    70. 	{
    71. 		cout << "Rectangle : _width" << ":" << width << endl;
    72. 		cout << "Rectangle : _height" << ":" << height << endl;
    73. 	}
    74.  
    75. public:
    76. 	int _rightAngleCounts;//直角个数，声明成员变量时不给默认值
    77. };

    这段代码中， 子类和父类各自有各自的打印函数，并且子类的成员变量变成了直角个数_rightAngleCounts，目的是为了方便理解后面的子类默认成员函数的生成规则。

    子类和普通类的默认成员函数不同点：

    ① 子类的构造函数必须调用父类的构造函数初始化父类的那一部分成员。如果父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。

    ② 子类的拷贝构造函数必须调用父类的拷贝构造完成父类的拷贝初始化。

    ③ 子类的operator=必须要调用父类的operator=完成父类的赋值。

    ④ 子类的析构函数会在被调用完成后自动调用父类的析构函数清理父类成员。因为这样才能保证子类对象先清理子类成员再清理父类成员的顺序。

    ⑤ 子类对象初始化先调用父类构造再调子类构造。

    ⑥ 子类对象析构清理先调用子类析构再调父类的析构。

    1.规则①  

    规则① 子类的构造函数必须调用父类的构造函数初始化父类的那一部分成员。如果父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。

    由于Ranctangle继承了Shape类的成员变量_width和_height，再加上自己的成员变量_rightAngleCounts，子类一共有3个成员变量，现在写子类的构造函数：

    1.     Rectangle(float width = 20, float height = 20, int rightAngleCounts = 4)
    2. 		:_width(width),
    3. 		_height(height),
    4. 		_rightAngleCounts(rightAngleCounts)
    5. 	{
    6. 		cout << "Rectangle(float width = 20, float height = 20, int rightAngleCounts = 4)" << endl;
    7. 	}

    但是编译报错：

    这是因为父类有默认构造函数，子类必须调用父类的默认构造函数去初始化父类的那一部分成员，所以当父类有默认构造函数时，子类不用在自己的构造函数内初始化父类的那一部分成员，只初始化自己的成员就可以了：

    1.     Rectangle(int rightAngleCounts = 4)
    2.         :_rightAngleCounts(rightAngleCounts)
    3. 	{
    4. 		cout << "Rectangle()" << endl;
    5. 	}

    编译通过。我们知道，默认构造函数分为3种：

    （1）我们没写，编译器默认自动生成

    （2）我们写的无参默认构造函数

    （3）我们写的带参全缺省默认构造函数 

    假如父类的构造函数不是以上3种呢？也就是父类没有默认的构造函数呢？子类如何初始化？

    父类构造函数写成这样就不是默认构造函数：

    1.     Shape(float width, float height)
    2. 		:_width(width)
    3. 		,_height(height)
    4. 	{
    5. 		cout << "Shape()" << endl;
    6. 	}

     那么子类构造函数只初始化子类的成员还可行吗？发现编译出错：

    当父类没有默认构造函数时，子类的初始化列表必须显式调用父类的默认构造函数：

    1.     Rectangle(float width = 10,float height = 10,int rightAngleCounts = 4)
    2. 		:Shape(width, height)
    3. 		,_rightAngleCounts(rightAngleCounts)
    4. 	{
    5. 		cout << "Rectangle()" << endl;
    6. 	}

    这时候，显式调用父类默认构造函数，是把当作一个整体去调父类的构造函数

    1. int main()
    2. {
    3. 	Rectangle r1(6,6,4);
    4.  
    5. 	return 0;
    6. }

    监视：都初始化成功了

    总结：

    （1）父类有默认构造函数，子类只需要在构造函数中初始化子类自己的成员

    （2）父类没有默认构造函数，子类要在构造函数初始化列表显式调用父类的构造函数，再初始化子类自己的成员

    2.规则②

    规则② 子类的拷贝构造函数必须调用父类的拷贝构造完成父类的拷贝初始化。

    子类的拷贝构造函数该如何写呢？

    调用父类拷贝构造函数时，将子类对象作为参数传给父类拷贝构造函数，这时会发生切片行为，将子类对象中父类成员部分切片赋值给父类成员，完成父类拷贝构造；再将子类自己的成员初始化为拷贝对象的子类成员值：

    1. 	Rectangle(const Rectangle& r)
    2. 		:Shape(r)//切片，子类对象赋值给父类引用
    3. 		, _rightAngleCounts(r._rightAngleCounts)//子类自己的成员初始化为拷贝对象的子类成员值
    4. 	{
    5. 		cout << "Rectangle(const Rectangle& r)" << endl;
    6. 	}
    1. int main()
    2. {
    3. 	Rectangle r1(6,6,4);
    4. 	Rectangle r2(r1);//拷贝构造
    5. 	
    6. 	return 0;
    7. }

    3.规则③

    规则③ 子类的operator=必须要调用父类的operator=完成父类的赋值

    如果子类的赋值运算符重载函数里只调用子类的operator=，那么会发生栈溢出：

    1. 	Rectangle& operator=(const Rectangle& r)
    2. 	{
    3. 		if (this != &r)
    4. 		{
    5. 			Shape::operator=(r);
    6. 			_rightAngleCounts = r._rightAngleCounts;
    7. 		}
    8. 		cout << "Rectangle& operator=(const Rectangle& r)" << endl;
    9.  
    10. 		return *this;
    11. 	}
    1. int main()
    2. {
    3. 	Rectangle r1(6,6,4);
    4. 	Rectangle r3(9,9,4);
    5. 	r3 = r1;//赋值运算符重载
    6.  
    7. 	return 0;
    8. }

     这是因为子类的operator=和父类的operator=同名，构成隐藏，调不到父类的operator=，只会不断调用自己的operator=，就会发生栈溢出。那如何才能访问到父类的operator=呢？加父类作用域，指定访问的是父类的operator=即可:

    1. 	Rectangle& operator=(const Rectangle& r)
    2. 	{
    3. 		if (this != &r)
    4. 		{
    5. 			Shape::operator=(r);//加父类作用域，指定访问的是父类的operato=
    6. 			_rightAngleCounts = r._rightAngleCounts;
    7. 		}
    8.         
    9.         cout << "Rectangle& operator=(const Rectangle& r)" << endl;
    10. 		return *this;
    11. 	}

    4.规则④

    规则④ 子类的析构函数会在被调用完成后自动调用父类的析构函数清理父类成员。因为这样才能保证子类对象先清理子类成员再清理父类成员的顺序

    如果按照前面的思路，先显式调用父类的析构函数，会报错：

    1. 	~Rectangle()
    2. 	{
    3. 		~Shape();
    4. 	}

     这是由于父类的析构函数和子类的析构函数构成隐藏，奇不奇怪？

    按照隐藏的定义，父类和子类的同名函数才会构成隐藏，为什么父类和子类的析构函数不同名也会构成隐藏呢？

    这是因为多态的缘故，任何类的析构函数名都会被统一处理成destructor( )。所以父类和子类析构函数同名，会构成隐藏。解决方法就是加父类作用域，指定访问的是父类的析构函数就可以了：

    1. 	~Rectangle()
    2. 	{
    3. 		Shape::~Shape();
    4.  
    5. 		//清理子类自己的空间
    6. 		//delete ptr;
    7.  
    8. 		cout << "~Rectangle()" << endl;
    9. 	}
    1. int main()
    2. {
    3. 	Rectangle r1(6,6,4);
    4.  
    5. 	return 0;
    6. }

    但是，会发现，竟然调用了2次父类的析构函数：（这里调了两次父类析构函数没有崩的原因是父类的析构函数啥也没干）

     这是因为，构造子类对象时，先调用父类构造函数，再调用子类构造函数，即规则⑤，如果按照正确的析构顺序，那么就得先调用子类的析构函数，再调用父类的析构函数。为了保证析构时，先调用子类的析构函数，再调用父类的析构函数的顺序，会在调用完子类析构函数后，自动再调用一次父类的析构函数。所以就出现了上面调用了两次父类析构函数的情况。

    其实析构函数比较特殊，不需要显式调用父类析构函数，因为子类析构函数调用完毕后，会自动调用父类的析构函数：

    1. 	~Rectangle()
    2. 	{
    3. 		//清理自己的空间
    4. 		//delete ptr;
    5.  
    6. 		cout << "~Rectangle()" << endl;
    7. 	}

     这就符合先构造的后析构的顺序，即规则⑥：

     子类对象构造函数和析构函数调用顺序：

    五、继承和友元

    （1）友元关系不能被继承

    （2）根据友元性质，父类友元可以直接访问父类的所有成员，也可以访问子类的共有成员，但不能访问子类私有成员和保护成员

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #include
    3. using namespace std;
    4.  
    5. class Rectangle;//前置声明Rectangle类
    6. class Shape
    7. {
    8. public:
    9. 	friend void fun(Shape& s, Rectangle& r);//声明fun是Shape类的友元
    10.  
    11. 	//构造函数
    12. 	Shape(float width, float height)
    13. 		:_width(width),
    14. 		_height(height)
    15. 	{
    16. 		cout << "Shape()" << endl;
    17. 	}
    18.  
    19. 	//拷贝构造函数
    20. 	Shape(const Shape& s)
    21. 		:_width(s._width),
    22. 		_height(s._height)
    23. 	{
    24. 		cout << "Shape(const Shape& s)" << endl;
    25. 	}
    26.  
    27. 	//赋值运算符重载函数
    28. 	Shape& operator=(const Shape& p)
    29. 	{
    30. 		cout << "Shape& operator=(const Shape& p)" << endl;
    31. 		if (&p != this)
    32. 		{
    33. 			_width = p._width;
    34. 			_height = p._height;
    35. 		}
    36.  
    37. 		return *this;
    38. 	}
    39.  
    40. 	//析构函数
    41. 	~Shape()
    42. 	{
    43. 		cout << "~Shape()" << endl;
    44. 	}
    45.  
    46. 	void setWidth(float w)
    47. 	{
    48. 		_width = w;
    49. 	}
    50.  
    51. 	void setHeight(float h)
    52. 	{
    53. 		_height = h;
    54. 	}
    55.  
    56. 	void ShapePrintf()
    57. 	{
    58. 		cout << "Shape : _width" << ":" << _width << endl;
    59. 		cout << "Shape : _height" << ":" << _height << endl;
    60. 	}
    61.  
    62. public:
    63. 	float _width;
    64. 	float _height;
    65. };
    66.  
    67. class Rectangle : public Shape
    68. {
    69. public:
    70. 	
    71. 	//构造函数
    72. 	Rectangle(float width = 10, float height = 10, int rightAngleCounts = 4)
    73. 		:Shape(width, height)
    74. 		, _rightAngleCounts(rightAngleCounts)
    75. 	{
    76. 		cout << "Rectangle()" << endl;
    77. 	}
    78.  
    79. 	//拷贝构造函数
    80. 	Rectangle(const Rectangle& r)
    81. 		:Shape(r)//切片，子类对象赋值给父类引用
    82. 		, _rightAngleCounts(r._rightAngleCounts)//子类自己的成员初始化为拷贝对象的子类成员值
    83. 	{
    84. 		cout << "Rectangle(const Rectangle& r)" << endl;
    85. 	}
    86.  
    87. 	//赋值运算符重载函数
    88. 	Rectangle& operator=(const Rectangle& r)
    89. 	{
    90. 		if (this != &r)
    91. 		{
    92. 			Shape::operator=(r);
    93. 			_rightAngleCounts = r._rightAngleCounts;
    94. 		}
    95. 		cout << "Rectangle& operator=(const Rectangle& r)" << endl;
    96.  
    97. 		return *this;
    98. 	}
    99.  
    100. 	//析构函数
    101. 	~Rectangle()
    102. 	{
    103. 		//Shape::~Shape();
    104.  
    105. 		//清理自己的空间
    106. 		//delete ptr;
    107.  
    108. 		cout << "~Rectangle()" << endl;
    109. 	}
    110.  
    111. 	float Area()
    112. 	{
    113. 		return _width * _height;
    114. 	}
    115.  
    116. 	void RectanglePrintf(float width, float height)
    117. 	{
    118. 		cout << "Rectangle : _width" << ":" << width << endl;
    119. 		cout << "Rectangle : _height" << ":" << height << endl;
    120. 	}
    121.  
    122. public://将子类自己的成员变量定义为公有
    123. 	int _rightAngleCounts;//直角个数
    124. };
    125.  
    126. //友元函数
    127. void fun(Shape& s, Rectangle& r)
    128. {
    129. 	cout << "fun:s._width = " << s._width << endl;
    130. 	cout << "fun:r._rightAngleCounts = " << r._rightAngleCounts << endl;//子类自己的成员变量为公有时，友元可以访问
    131. }
    132.  
    133. int main()
    134. {
    135. 	Shape s(10, 10);
    136. 	Rectangle r(6, 6, 4);
    137.  
    138. 	fun(s, r);
    139.  
    140. 	return 0;
    141. }

     将子类自己的成员变量定义为公有时，友元可以访问：

     但是将子类自己的成员变量定义为保护或私有时，友元不可以访问，将上述代码中的子类自己的成员变量的访问限定符：

    1. public://将子类自己的成员变量定义为公有
    2. 	int _rightAngleCounts;//直角个数

    由公有改为保护：

    1. private://将子类自己的成员变量定义为保护
    2. 	int _rightAngleCounts;//直角个数

     编译就会报错：

    六、继承和静态成员

    父类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 。 

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #include
    3. using namespace std;
    4.  
    5. class Shape
    6. {
    7. public:
    8. 	//构造函数
    9. 	Shape(float width = 10, float height = 10)
    10. 		:_width(width),
    11. 		_height(height)
    12. 	{
    13. 		++_count;
    14. 	}
    15.  
    16. public:
    17. 	float _width;
    18. 	float _height;
    19. 	static int _count;
    20. };
    21.  
    22. int Shape::_count = 0;
    23.  
    24. //长方形
    25. class Rectangle : public Shape
    26. {
    27. public:
    28. 	int _rightAngleCounts;//直角个数
    29. };
    30.  
    31. //三角形
    32. class Triangle : public Shape
    33. {
    34. public:
    35. 	float _acuteAngleCounts;//锐角个数
    36. };
    37.  
    38.  
    39. int main()
    40. {
    41. 	Shape s;
    42. 	Rectangle r;
    43. 	Triangle c;
    44. 	
    45. 	cout << Shape::_count << endl;
    46. 	cout << Rectangle::_count << endl;
    47. 	cout << Triangle::_count << endl;
    48.  
    49. 	Triangle::_count = 20;
    50.  
    51. 	cout << Shape::_count << endl;
    52. 	cout << Rectangle::_count << endl;
    53. 	cout << Triangle::_count << endl;
    54.  
    55. 	return 0;
    56. }

     _count在整份代码中只有一份：

    定义了3个类对象，_count就会自增3次变为3；重置了Circle类中的_count，父类中的_count也就被重置了：

     

    静态成员可以统计整个代码一共产生了多少个对象，由于子类无论构造还是拷贝构造都会调用父类的构造函数（父类的拷贝构造对象没有被统计在内，因为父类的拷贝构造函数没有调用父类的构造函数）。

    七、菱形继承

    继承关系分为：单继承、多继承、菱形继承。 

     1.单继承

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

    2.多继承

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

    多继承会导致菱形继承。 

    3.菱形继承

    是多继承的一种特殊情况：

     

    菱形继承会存在两个问题：

    （1）数据冗余

    （2）二义性

    如上面的TriangleEmbeddedRectangle对象中会存在两份Shape成员：

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #include
    3. using namespace std;
    4.  
    5. class Shape
    6. {
    7. public:
    8. 	//构造函数
    9. 	Shape(float width = 10, float height = 10)
    10. 		:_width(width),
    11. 		_height(height)
    12. 	{}
    13.  
    14. public:
    15. 	float _width;
    16. 	float _height;
    17. };
    18.  
    19.  
    20. //长方形
    21. class Rectangle : public Shape
    22. {
    23. public:
    24. 	int _rightAngleCounts;//直角个数
    25. };
    26.  
    27. //三角形
    28. class Triangle : public Shape
    29. {
    30. public:
    31. 	int _acuteAngleCounts;//锐角个数
    32. };
    33.  
    34. //三角形内嵌于长方形
    35. class TriangleEmbeddedRectangle : public Rectangle, public Triangle
    36. {
    37. public:
    38. 	int _sideCounts;//边数
    39. };
    40. int main()
    41. {
    42. 	TriangleEmbeddedRectangle t;
    43. 	t._width = 60;//报错，指向不明
    44. 	
    45. 	return 0;
    46. }

     数据冗余：Rectangle和Triangle都有_width和_height，TriangleEmbeddedRectangle也只有一个，_width和_height，但是编译错误却表示有两个_width：

    二义性：访问_width时，不知道要访问谁的_width：

    指定作用域可以解决二义性的问题，即指定访问谁的_width：

    1. int main()
    2. {
    3. 	TriangleEmbeddedRectangle t;
    4. 	t.Triangle::_width = 60;//指定访问Triangle的_width
    5. 	
    6. 	return 0;
    7. }

     编译OK。

    但是这只解决了二义性的问题，并不能解决数据冗余的问题，TriangleEmbeddedRectangle的对象t中还是有两份_width和_height。菱形虚拟继承既可以解决数据冗余也可以解决二义性的问题。

    八、菱形虚拟继承

    1.虚继承

    在两个直接父类的继承方式访问限定符前加vitual：

     

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #include
    3. using namespace std;
    4.  
    5. class Shape
    6. {
    7. public:
    8. 	//构造函数
    9. 	Shape(float width = 10, float height = 10)
    10. 		:_width(width),
    11. 		_height(height)
    12. 	{}
    13.  
    14. public:
    15. 	float _width;
    16. 	float _height;
    17. };
    18.  
    19.  
    20. //长方形
    21. class Rectangle : virtual public Shape//虚继承
    22. {
    23. public:
    24. 	int _rightAngleCounts;//直角个数
    25. };
    26.  
    27. //三角形
    28. class Triangle : virtual public Shape//虚继承
    29. {
    30. public:
    31. 	int _acuteAngleCounts;//锐角个数
    32. };
    33.  
    34. //三角形内嵌于长方形
    35. class TriangleEmbeddedRectangle : public Rectangle, public Triangle
    36. {
    37. public:
    38. 	int _sideCounts;//边数
    39. };
    40.  
    41. int main()
    42. {
    43. 	TriangleEmbeddedRectangle t;
    44. 	t.Triangle::_width = 60;
    45. 	
    46. 	return 0;
    47. }

    监视发现现在改变的是同一个_width，Rectangle、Triangle和Shape中的_width是同一个_width：

     现在可以不用指定作用域了。

    那么C++编译器是如何通过虚继承解决数据冗余和二义性的问题的呢？

    由于监视窗口被编译器处理过，看不到真实过程。可以使用内存窗口来查看。

    2.虚继承的解决数据冗余和二义性的原理

    （1）普通继承 

     对于Shape、Rectangle、Triangle、TriangleEmbeddedRectangle类，如果没有虚继承，仅仅只是菱形继承

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #define  _CRT_SECURE_NO_WARNINGS  1
    3. #include
    4. using namespace std;
    5.  
    6. class Shape
    7. {
    8. public:
    9. 	//构造函数
    10. 	Shape(float width = 10,float height = 10)
    11. 		:_width(width)
    12. 		,_height(height)
    13. 	{}
    14.  
    15. public:
    16. 	float _width;
    17. 	float _height;
    18. };
    19.  
    20.  
    21. //长方形
    22. class Rectangle : public Shape//非虚继承
    23. {
    24. public:
    25. 	int _rightAngleCounts;//直角个数
    26. };
    27.  
    28. //三角形
    29. class Triangle : public Shape//非虚继承
    30. {
    31. public:
    32. 	int _acuteAngleCounts;//锐角个数
    33. };
    34.  
    35. //三角形内嵌于长方形
    36. class TriangleEmbeddedRectangle : public Rectangle, public Triangle
    37. {
    38. public:
    39. 	int _sideCounts;//边数
    40. };
    41.  
    42. int main()
    43. {
    44. 	TriangleEmbeddedRectangle t;
    45. 	t.Rectangle::_width = 1;
    46. 	t.Rectangle::_height = 2;
    47. 	t.Triangle::_width = 3;
    48. 	t.Triangle::_height = 4;
    49. 	t._rightAngleCounts = 5;
    50. 	t._acuteAngleCounts = 6;
    51. 	t._sideCounts = 7;
    52.  
    53. 	return 0;
    54. }

    F10-调试-窗口-内存，输入&t，enter，将列改为4：

    由于_width和_height的类型为float型，因此内存中存放的是浮点数的十六进制表示形式，VS编译器内存以小端形式存储。F10走到return 0：

    可以看到内存中，蓝色为Rectangle的成员，绿色为Triangle的成员，Rectangle中存了一份Shape的成员，Triangle中存了一份Shape的成员，这就存在数据冗余，本来只需要存一份Shape就够了，但是内存中存了两份。

    （2）虚继承

    如果改成虚继承

    1. #define  _CRT_SECURE_NO_WARNINGS  1
    2. #define  _CRT_SECURE_NO_WARNINGS  1
    3. #include
    4. using namespace std;
    5.  
    6. class Shape
    7. {
    8. public:
    9. 	//构造函数
    10. 	Shape(float width = 10,float height = 10)
    11. 		:_width(width)
    12. 		,_height(height)
    13. 	{}
    14.  
    15. public:
    16. 	float _width;
    17. 	float _height;
    18. };
    19.  
    20.  
    21. //长方形
    22. class Rectangle : virtual public Shape//虚继承
    23. {
    24. public:
    25. 	int _rightAngleCounts;//直角个数
    26. };
    27.  
    28. //三角形
    29. class Triangle : virtual public Shape//虚继承
    30. {
    31. public:
    32. 	int _acuteAngleCounts;//锐角个数
    33. };
    34.  
    35. //三角形内嵌于长方形
    36. class TriangleEmbeddedRectangle : public Rectangle, public Triangle
    37. {
    38. public:
    39. 	int _sideCounts;//边数
    40. };
    41.  
    42. int main()
    43. {
    44. 	TriangleEmbeddedRectangle t;
    45. 	t.Rectangle::_width = 1;
    46. 	t.Rectangle::_height = 2;
    47. 	t.Triangle::_width = 3;
    48. 	t.Triangle::_height = 4;
    49. 	t._rightAngleCounts = 5;
    50. 	t._acuteAngleCounts = 6;
    51. 	t._sideCounts = 7;
    52.  
    53. 	return 0;
    54. }

    会发现Rectangle指针中存了地址0x00D39B54，Triangle的指针中也存了地址0x00D39B30，这两个地址是用来干嘛的呢？

    新开两个内存分别输入0x00D39B54和0x00D39B30，在它们的下一个位置分别存放了0x14和0x0C，这两个都是偏移量，0x00B9FCDC+0x14=0x00B9FCF0，0x00B9FCE4+0x0C=0x00B9FCF0，都指向了同一地址0x00B9FCF0：这个地址是Shape成员的起始地址：

    普通继承存放两份Shape成员，而虚继承只需要存在一份Shape成员即可，通过指针找到虚基表，通过虚基表指针的偏移量计算出Shape成员的起始地址。

     菱形虚拟继承原理图：

    虚拟菱形继承相比较于菱形继承，TriangleEmbeddedRectangle对象t的直接父类Rectangle和Triangle中存储的不再是Shape的成员，而是Shape的偏移量地址，通过该指针找到虚基表之后，计算偏移，就能知道Shape成员存放的地址，位于Rectangle和Triangle成员的下边，不再像普通继承那样位于Rectangle和Triangle成员的上边，这时候Shape既不属于Rectangle也不属于Triangle。

    无论Shape类有多大，付出的代价只有2个指针，即8个字节，解决了数据冗余问题；整个内存中只需要存一份Shape的成员，解决了二义性。

    一般不建议设计多继承，这样就不会出现菱形继承，也就不会有数据冗余和二义性的问题。

    九.继承和组合

    （1） public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。如Shape和Rectangle。他们之间是强关联关系。

    （2）组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。如Room和Door。

    他们之间是弱关联关系

    1. #include
    2. using namespace std;
    3.  
    4. class Room
    5. {
    6. public:
    7. 	float _roomHegiht;//房间高度
    8. 	int layers;//层数
    9. };
    10.  
    11. class Door
    12. {
    13. public:
    14. 	float _doorHegiht;//门高度
    15. 	string brand = "梦天木门";//品牌
    16. };

     

    （3）优先使用对象组合，而不是类继承 。为了降低对象之间的关联度

    （4）继承允许根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。父类所有非私有成员对子类都可见，父类的改变会影响子类，父类的封装对子类不太起作用。
    （5）继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
    （6）对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于保持每个类被封装。子类只能使用父类的共有成员 ，子类和父类关联度低。
    （7）实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

  • 相关阅读:
    SpringBoot集成ES、使用Java API对其进行简单的测试
    部署jenkins
    Vue.js+Node.js全栈开发教程：Vue.js数据同步
    wpf datagrid常用绑定以及格式
    Kafka Tool（Kafka 可视化工具）安装及使用教程
    陈宏申：浅谈京东电商商品文案挖掘难点与优化实践
    java计算机毕业设计双峰县在线房屋租售网站源代码+数据库+系统+lw文档
    案例篇：Python爬虫的多重领域使用
    【无标题】
    Neuron Newsletter 2022-08｜新增 Beckhoff ADS、OPC DA 驱动
  • 原文地址：https://blog.csdn.net/gx714433461/article/details/125731105