C++之继承详解

转x33g5p2x  于2022-02-07 转载在 C/C++  
字(12.6k)|赞(0)|评价(0)|浏览(657)

继承

继承的概念及定义

继承的概念

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

比如在一个学生管理系统中，需要定义学生、老师、保安等等结构体：

学生有它的名字，电话号码，地址，年龄，学号：

  1. class Student
  2. {
  3.     string _name;
  4.     int _tel;
  5.     string _address;
  6.     int _age;
  7.     
  8.     int _stuID;
  9. }

老师也有它的名字，电话号码，地址，年龄，外加工号：

  1. class Teacher
  2. {
  3.     string _name;
  4.     int _tel;
  5.     string _address;
  6.     int _age;
  7.     
  8.     int _workID;
  9. }

但是我们如果如果这样设计的话，我们发现有好多重复的信息，怎么解决呢？我们将重复的信息提取出来，重新建一个Person类：

  1. class Person
  2. {
  3.     string _name;
  4.     int _tel;
  5.     string _address;
  6.     int _age;
  7. }

此时Student、Teacher可以将Person进行复用：

  1. class Student
  2. {
  3.     Person _p;
  4.     int _stuID;
  5. }
  1. class Teacher
  2. {
  3.     Person _p;
  4.     int _workID;
  5. }

但是一般成员会设置成私有的，Student、Teacher不好去访问Person的成员所以C++就设计出来了继承：

  1. class Person
  2. {
  3. public:
  4.     void Print()
  5.     {
  6.         cout << "name:" << _name << endl;
  7.         cout << "age:" << _age << endl;
  8.     }
  9. protected:
  10.     string _name = "peter"; // 姓名
  11.     int _age = 18; // 年龄
  12. };
  13. //Student继承了Person，Student中就拥有了Person的成员
  14. //Person叫做父类/基类
  15. //Student叫子类/派生类
  16. class Student : public Person
  17. {
  18. protected:
  19.     int _stuID; // 学号
  20. };
  21. class Teacher : public Person
  22. {
  23. protected:
  24. 	int _workID; // 工号
  25. };
  26. int main()
  27. {
  28.     Student s;
  29.     Teacher t;
  30.     s.Print();
  31.     t.Print();
  32.     return 0;
  33. }

继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。Person叫做父类/基类
Student和Teacher叫子类/派生类，这里体现出了Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可以看到变量的复用。调用Print可以看到成员函数的复用。

继承定义

定义格式

我们可以看到Student是派生类，public是继承方式，Person是基类：

继承关系和访问限定符

继承基类成员访问方式的变化

那么在继承当中，基类成员访问方式是怎么变化的呢？

我们首先设定权限大小：

public>protected>private

类成员/继承方式public继承protected继承private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private成员
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员在派生类中不可见在派生类中不可见在派生类中不可见

可以通过这个表格可以总结出基类继承给子类的成员的访问方式的变为：min(访问方式，继承方式)，访问方式变为，父类中的访问方式和继承方式中取权限小的。

下面我们看这样的一个代码：

  1. class Person
  2. {
  3. public:
  4.     void Print()
  5.     {
  6.         cout << "name:" << _name << endl;
  7.         cout << "age:" << _age << endl;
  8.     }
  9. protected:
  10.     string _name = "peter"; // 姓名
  11. private:
  12.     int _age = 18; // 年龄
  13. };
  14. class Student : public Person
  15. {
  16.     void func()
  17.     {
  18.         Print();//公有的
  19.         _name = "张三";//protected，类内部可以访问_name
  20.         _age = 18;//error,不可见，对象的物理空间上它是存在的，但是语法上不允许子类使用
  21.     }
  22. protected:
  23.     int _stuID; // 学号
  24. };
  25. int main()
  26. {
  27.     Student s;
  28. 	
  29.     return 0;
  30. }

我们将基类成员name设置成保护，age设置成私有，派生类继承方式为public，所以name在子类中的访问方式变为了保护，所以类内部可以访问name，age在子类中的访问方式变为了不可见，注意这里的不可见的意思是：对象的物理空间上它是存在的，但是语法上不允许子类使用，如果我们去修改age是会报错的：

实际上C早期设计继承方式和访问限定符时，考虑复杂，把各种情况都考虑进去了，但是实际的使用中，用的最多的是public继承。基类成员的访问设定符设置成public或者protected，虽然C设计的复杂，但是我们尽量用简单的。继承中，一个类中尽量不要使用private。因为private在子类中不可见，尽量用protected

总结：

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

基类和派生类对象赋值转换(切片)

我们写这样的类：

  1. class Person
  2. {
  3. protected :
  4.     string _name; // 姓名
  5.     string _sex; // 性别
  6.     int _age; // 年龄
  7. };
  8. class Student : public Person
  9. {
  10. public :
  11. 	int _No ; // 学号
  12. };

那么我们创建一个基类对象，创建一个子类对象：

  1. int main()
  2. {
  3.     Person p;
  4.     Student s;
  5.     p = s;//子类对象赋值给父类对象
  6. }

我们将子类对象赋值给父类对象这样是可以的，子类赋值给父类的这个过程称为切割或者切片：

同时还可以是指针和引用：

  1. Person *pr = &s;

pr指向父类这一部分成员

  1. Person& ref = s;

ref是父类这一部分的别名

那么我们如果像将父类对象赋值给子类对象呢？

  1. s = p;

这样是错误的，父类对象赋值给子类对象是不可以的

继承中的作用域(隐藏)

我们首先来看下面的例子：

  1. // Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
  2. class Person
  3. {
  4. protected :
  5.     string _name = "小李子"; // 姓名
  6.     int _num = 111; // 身份证号
  7. };
  8. class Student : public Person
  9. {
  10. public:
  11. void Print()
  12. {
  13.     cout<<" 姓名:"<<_name<< endl;
  14.     cout<<" 身份证号:"<<Person::_num<< endl;
  15.     cout<<" 学号:"<<_num<<endl;
  16. }
  17. protected:
  18. 	int _num = 999; // 学号
  19. };
  20. void Test()
  21. {
  22.     Student s1;
  23.     s1.Print();
  24. };

可以看到基类和子类中有相同名字的成员，那么我们在打印时，会打印父类的num呢还是子类的num呢？我们运行一下：

我们发现打印了子类的num，这里有一个隐藏的概念：

当子类和父类有同名成员时，子类成员会隐藏父类成员。这个称为隐藏或者重定义。

那么我们如果想打印基类的num成员呢？此时我们需要指定类域：

  1. cout<<" 学号:"<<Person::_num<<endl;

可以看到学号发生了改变，它打印了父类的num

接下来再看这样的一份代码：

  1. class A
  2. {
  3. public:
  4.     void func()
  5.     {
  6.         cout<<"func()"<<endl;
  7.     }
  8. };
  9. class B:public A
  10. {
  11. public:
  12.     void func(int i)
  13.     {}
  14. };
  15. int main()
  16. {
  17.     B b;
  18.     b.func(10);
  19.     b.A::func();//调用父类的话需要指定作用域
  20. }

和前面的成员变量一样，成员函数也是相同的道理，这里构成隐藏，要是想访问父类的成员函数需要指定类域
很多人会误解这里的func函数构成重载，但是函数重载的前提要求在同一作用域，两个func函数不在统一作用域，所以A和B类的func函数构成隐藏关系，只要函数名相同就构成隐藏。建议自己定义尽量不要在父子类中定义同名成员变量和函数

总结：

  • 在继承体系中基类和派生类都有独立的作用域。
  • 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
  • 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
  • 注意在实际中在继承体系里面最好不要定义同名的成员。

派生类的默认成员函数

6个默认成员函数，我们这里讲解4个，取地址重载我们就不说了，因为这两个我们自己很少实现。默认成员函数：“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

首先我们来看构造函数：

构造函数

  1. class Person
  2. {
  3. public:
  4.     //构造函数
  5.     Person(const char* name = "peter")
  6.     	  : _name(name)
  7.      {
  8.      	cout<<"Person()" <<endl;
  9.      }
  10. protected:
  11. 	string _name;
  12. };
  13. class Student : public Person
  14. {
  15. public:
  16.     //子类构造函数 我们不写编译器默认生成
  17.     //1.自己的内置类型成员
  18.     //2.自己的自定义类型成员
  19.     //3.继承的父类成员
  20. private:
  21.     int _id;
  22.     string _address;
  23. };
  24. int main()
  25. {
  26.     Student s;
  27.     return 0;
  28. }

这里我们发现我们没有定义父类对象，但是打印的显示，调用了父类的构造函数为什么呢？是因子类构造函数我们不写，编译器默认生成构造函数，默认生成的构造函数会这样处理：

  1. 继承的父类成员调用父类的默认构造函数初始化
  2. 自己的自定义类型成员(调用自定义类型的构造函数)
  3. 自己的内置类型成员，不处理(除非给了声明时缺省值)

我们调试发现，确实是这样子的：

父类里的_name已经初始化了，内置类型并没有处理，_address调用string类的默认构造函数进行初始化。

如果我们没有写父类写了构造函数，我们就要自己实现子类构造函数，不然会报错父类没有合适的默认构造函数

在显式写子类构造函数时，对父类的成员初始化时需要注意的是父类被看成一个整体：

  1. Student(const char* name,int id,const char* address)
  2.     :_id(id)
  3.     ,_address(address)
  4. {}

那么我们怎么给父类的成员进行初始化呢？将父类看成一个整体进行初始化：

  1. Student(const char* name,int id,const char* address)
  2. 	:Person(name)    
  3.     :_id(id)
  4.     ,_address(address)
  5. {}

注意：

不在初始化列表显式的调用父类的构造函数初始化的话，编译器会调用默认的构造函数去初始化

那么构造函数处理完，我们再来看拷贝构造函数：

拷贝构造函数

  1. class Person
  2. {
  3. public:
  4.     //构造函数
  5.     Person(const char* name = "peter")
  6.     	  : _name(name)
  7.      {
  8.      	cout<<"Person()" <<endl;
  9.      }
  10.     //拷贝构造函数
  11.     Person(const Person& p)
  12.      : _name(p._name)
  13.     {
  14.      	cout<<"Person(const Person& p)" <<endl;
  15.     }
  16. protected:
  17. 	string _name;
  18. };
  19. class Student : public Person
  20. {
  21. public:
  22. private:
  23.     int _id;
  24.     string _address;
  25. };
  26. int main()
  27. {
  28.     Student s;
  29.     Student s1(s);
  30.     return 0;
  31. }

我们可以看到它调用了父类的拷贝构造函数，子类拷贝构造函数我们不写编译器默认生成
默认生成的拷贝构造函数会这样处理：

  1. 继承的父类成员调用父类的拷贝构造函数初始化
  2. 自己的自定义类型成员(调用自定义类型的拷贝构造函数)
  3. 自己的内置类型成员，进行值拷贝

那么我们要是自己怎么实现呢？我们怎么对父类的那一部分进行拷贝呢？还记不记得前面讲的切片，这里就用到了：

  1. Student(const Student& s)
  2.        :Person(s)//切片  这里不写会调用默认构造函数
  3.        ,_id(s._id)
  4.        ,_address(s._address)
  5. {}

如果这里不写Person(s)，这里会调用默认构造函数：

如果要自己实现，就要类似这样处理，但是像这里的Student是不需要自己去实现的，默认实现的就够用，只有当子类中存在深浅拷贝问题才需要自己实现。

下面我们来看赋值重载：

赋值重载函数

  1. class Person
  2. {
  3. public:
  4. 	//赋值重载
  5.      Person& operator=(const Person& p)
  6.      {
  7.          cout<<"Person operator=(const Person& p)"<< endl;
  8.          if (this != &p)
  9.          _name = p ._name;
  11.      	return *this ;
  12. 	 }
  13. protected:
  14. 	string _name;
  15. };
  16. class Student : public Person
  17. {
  18. public:
  19. private:
  20.     int _id;
  21.     string _address;
  22. };
  23. int main()
  24. {
  25.     Student s;
  26.     Student s1;
  27.     s1 = s;
  28.     return 0;
  29. }

子类赋值重载函数我们不写编译器默认生成，默认生成的赋值重载函数会这样处理：

  1. 继承的父类成员调用父类的赋值重载函数
  2. 自己的自定义类型成员(调用自定义类型的赋值重载函数)
  3. 自己的内置类型成员，进行值拷贝

那么需要自己实现呢？这样实现：

  1. Student& operator=(const Student& s)
  2. {
  3.     if(*this != s)
  4.     {
  5.         _id = s._id;
  6.         _address = s._address;
  7.         operator=(s);
  8.     }
  9.     return *this;
  10. }

我们发现这样写代码之间崩了，为什么呢？是因为子类的operator=和父类的operator=构成了隐藏。并且这里发生了切片，所以需要指定作用域：

  1. Student& operator=(const Student& s)
  2. {
  3.     if(*this != s)
  4.     {
  5.         _id = s._id;
  6.         _address = s._address;
  7.         Person::operator=(s);//切片
  8.     }
  9.     return *this;
  10. }

最后，我们来看一下析构函数：

析构函数

  1. class Person
  2. {
  3. public:
  4.     //构造函数
  5.     Person(const char* name = "peter")
  6.     	  : _name(name )
  7.      {
  8.      	cout<<"Person()" <<endl;
  9.      }
  10.     //拷贝构造
  11.     Person(const Person& p)
  12.      : _name(p._name)
  13.      {
  14.      	cout<<"Person(const Person& p)" <<endl;
  15.      }
  16. 	//赋值重载
  17.      Person& operator=(const Person& p )
  18.      {
  19.          cout<<"Person operator=(const Person& p)"<< endl;
  20.          if (this != &p)
  21.          _name = p ._name;
  23.      	return *this ;
  24. 	 }
  25. 	//析构函数
  26.      ~Person()
  27.      {
  28.      	cout<<"~Person()" <<endl;
  29.      }
  30. protected:
  31. 	string _name;
  32. };
  33. class Student : public Person
  34. {
  35. public:
  36. private:
  37.     int _id;
  38.     string _address;
  39. };
  40. int main()
  41. {
  42.     Student s;
  43.     Student s1;
  44.     s1 = s;
  45.     return 0;
  46. }

当我们不去显式写析构函数时：

析构函数我们不写编译器默认生成，默认生成的析构函数会

  1. 继承的父类成员调用父类的析构函数
  2. 自己的自定义类型成员(调用自定义类型的析构函数)
  3. 自己的内置类型成员，不会处理

如果要自己实现呢？

  1. ~Student()
  2. {
  3.     ~Person();
  4.     //清理子类的资源
  5. }

这样是错误的，因为子类析构函数和父类析构函数构成隐藏，因为编译器会对析构函数名做特殊处理，所有类的析构函数名都会被处理成统一名字destructor()，为什么编译器会做这样的处理呢？因为析构函数在底层要构成多态的重写

我们需要加类域：

  1. ~Student()
  2. {
  3.     Person::~Person();
  4.     //清理子类的资源
  5. }

但是我们发现多析构了，为什么呢？因为子类的析构函数在执行结束之后会自动调用父类的析构函数
为了保证先构造的后释放，因为在构造函数中规则是父类是先被构造的，然后再构造子类的，所以子类的析构函数在执行结束之后会自动调用父类的析构函数，这样才能保证子类先调用析构函数清理，再调用父类析构函数清理，顺序符合一致的规则

所以我们不需要显式写父类的析构，因为编译器在子类析构执行完后会自动的去调用

  1. ~Student()
  2. {
  3.     //清理子类的资源
  4.     //自动的调用父类的析构
  5. }

继承和友元

  1. class Person
  2. {
  3. public:
  4.     friend void Print(const Person& p,const Student& s);
  5. protected :
  6.     string _name = "张三"; // 姓名
  7. };
  8. class Student : public Person
  9. {
  10. protected:
  11. 	int _num = 999; // 学号
  12. };
  13. void Print(const Person& p,const Student& s)
  14. {
  15.     cout<<" 姓名:"<<p._name<< endl;
  16.     cout<<" 学号:"<<s._num<<endl;
  17. }
  18. void Test()
  19. {
  20.     Person p;
  21.     Student s;
  22.     Print(p,s);
  23. };

我们看到Print函数是基类的友元，那么友元关系可以继承吗？

友元关系不能继承，基类的友元不能访问子类私有和保护成员

继承与静态成员

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

如果我们要统计产生多少个对象，就可以利用静态成员进行统计：

  1. class Person
  2. {
  3. public :
  4. 	Person () 
  5.     {
  6.         ++ _count ;
  7.     }
  8. protected :
  9. 	string _name ; // 姓名
  10. public :
  11. 	static int _count; // 统计人的个数。
  12. };
  13. int Person :: _count = 0;
  14. class Student : public Person
  15. {
  16. protected :
  17. 	int _stuNum ; // 学号
  18. };
  19. class Graduate : public Student
  20. {
  21. protected :
  22. 	string _seminarCourse ; // 研究科目
  23. };
  24. int main()
  25. {
  26. 	Student s1;
  27. 	Student s2;
  28. 	Student s3;
  30. 	Graduate g1;
  31. 	Graduate g2;
  32. 	Graduate g3;
  34. 	Person p1;
  35. 	Person p2;
  36. 	Person p3;
  37. 	cout << "人数 ：" << Person::_count << endl;
  39. 	return 0;
  40. }

菱形继承和菱形虚拟继承

菱形继承

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

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

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

菱形继承并不一定是固定这样的菱形形状才是菱形继承，在Teacher和Assitant类直接加一层继承关系也是可以的，只要有这个大体形状就可以。

只看这个图，大家能看出什么问题吗？

多继承是C++的一个坑，由多继承衍生出来菱形继承，但是早期设计的时候，没有办法，Java后续直接就不支持多继承了，多继承本身没有问题，但是支持多继承，就可能会出现菱形继承，我们可以发现Assistant类中会有两份Person成员，一份是Student继承下来的，一份是Teacher继承下来的，这样造成了数据冗余和二义性：

  1. class Person
  2. {
  3. public :
  4. 	string _name ; // 姓名
  5. };
  6. class Student : public Person
  7. {
  8. protected :
  9. 	int _num ; //学号
  10. };
  11. class Teacher : public Person
  12. {
  13. protected :
  14. 	int _id ; // 职工编号
  15. };
  16. class Assistant : public Student, public Teacher
  17. {
  18. protected :
  19. 	string _majorCourse ; // 主修课程
  20. };
  21. int main()
  22. {
  23.     // 这样会有二义性无法明确知道访问的是哪一个
  24.     Assistant a ;
  25.     a._name = "peter";
  26.     // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
  27.     a.Student::_name = "xxx";
  28.     a.Teacher::_name = "yyy";
  29. }

当我们对_name去写时，这样会有二义性编译器无法明确知道访问的是哪一个_name：

所以需要显示指定访问哪个父类的成员可以解决二义性问题：

  1. a.Student::_name = "Peter";
  2. a.Teacher::_name = "Mike";

但是这样并没有解决数据冗余的问题，C++委员会为了解决这个问题，就出现了菱形虚拟继承：

菱形虚拟继承

  1. class Person
  2. {
  3. public :
  4. 	string _name ; // 姓名
  5. };
  6. class Student : virtual public Person
  7. {
  8. protected :
  9. 	int _num ; //学号
  10. };
  11. class Teacher : virtual public Person
  12. {
  13. protected :
  14. 	int _id ; // 职工编号
  15. };
  16. class Assistant : public Student, public Teacher
  17. {
  18. protected :
  19. 	string _majorCourse ; // 主修课程
  20. };
  21. void Test ()
  22. {
  23.     Assistant a ;
  24.     a._name = "peter";
  25. }

菱形虚拟继承解决了数据冗余和二义性的问题，虽然在监视窗口看着有三份，其实这里的_name只有一份，监视窗口为了方便我们进行变量的查看，进行了优化，我们改其中的一个时，其他两个都会改变，下面我们在更底层的去了解菱形虚拟继承是怎么处理的，我们通过查看内存监视窗口进行调试，为了方便查看，我们定义下面的类：

  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. int main()
  22. {
  23.     D d;
  24.     d.B::_a = 1;
  25.     d.C::_a = 2;
  26.     d._b = 3;
  27.     d._c = 4;
  28.     d._d = 5;
  29. }

我们创建一个D对象，当是菱形继承时，我们通过查看D对象的地址来看看内存中成员构成的对象模型：

我们可以看到红色圈起来的是B，它里面有继承A的成员_a和它的成员_b，橙色圈起来的是C，它里面有继承A的成员_a和它的成员_c，整个蓝色圈起来的是D的对象模型。这个对象模型很清晰，也不复杂，容易理解。

那么菱形虚拟继承呢？我们来看看菱形虚拟继承怎么处理的：

  1. int main()
  2. {
  3.     D d;
  4.     d.B::_a = 1;
  5.     d.C::_a = 2;
  6.     d._b = 3;
  7.     d._c = 4;
  8.     d._d = 5;
  9.     
  10.     d._a = 0;
  11. }

动图演示：

通过动图演示后，我们可以看到在菱形继承中_a成员到了存到了最下面，对B、C、D中的_a都进行修改，我们发现修改的都是最下面的那一份，说明_a仅有一份，我们仔细观察在B中多了00 a9 7b 48这个内容，在C中多了 00 a9 7b 54这个内容：

我们在打开一个内存监视看看这两个是什么：

我们看到一个地址的下一个位置存的是14，十进制是20，那么另一个内容是什么呢？我们也来看看：

我们看到这个地址的下一个位置存的是c，十进制是12，那么这两个数字代表什么呢？实际上这两个地方存的是到_a的偏移量，那么为什么需要存偏移量呢？

还记不记得前面讲的切片，B b = d;我们前面说了切片是将d对象中的B类的部分赋值给b，B类的部分有_a成员，那么怎么找到这个B类的_a成员呢？此时就需要用偏移量去找。只有虚基类B和C需要用偏移量去找_a，其他都是正常去找。

我们通过汇编代码来验证一下：

  1. int main()
  2. {
  3.     B b;
  4.     b._a = 1;
  5.     b._b = 2;
  6. }

我们可以看到B类对象去访问_a时的汇编代码有三行，它是通过偏移量去访问的_a，而B类对象去访问_b时是直接去访问的。

我们再来看看B类的指针去访问_a：

  1. int main()
  2. {
  3.     B* p = &b;
  4.     p->_a = 3;
  6.     p = &d;
  7.     p->_a = 4;
  8. }

同样的我们发现去访问_a都是通过偏移量去找到的。

总结：

访问继承的虚基类对象成员_a都是取偏移量计算_a的位置，B类的对象、指针、引用去访问_a都要取偏移量计算_a的位置，可以看到虚继承后，解决了菱形继承，但是解决了菱形继承的同时，对象模型更复杂了，其次访问虚基类成员也付出了一定的效率代价

实际中，一般情况下，建议不要设计出菱形继承，那么就不会用菱形虚拟继承，就不会有这么多的问题。

继承和组合

  1. class A
  2. {
  3. public:
  4. 	void func(){}
  5. protected:
  6. 	int _a;
  7. };
  8. //B继承了A，可以复用A
  9. class B : public A
  10. {
  11. protected:
  12. 	int _b;
  13. };
  14. //C组合A，也可以复用A
  15. class C
  16. {
  17. private:
  18.     int _c;
  19.     A _a;
  20. };

A和B是继承关系，而A和C是组合关系，public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。B类复用A类是白箱复用(B里面既可以用A公有成员，也可以用保护的成员，也就是说，A所有成员对于B都是透明的，随便用，关联度高，A的改变，基本都会影响B，A的封装对B是不太起作用的)，而C类复用A类是黑箱复用(C里面只能用A公有的成员，A的保护成员私有成员对C是不透明的，那么C和A关联度就低，A的改变对C的影响小，A的封装对C是起作用的)

所以B和A之间是一种强关联关系，C和A之间是一种弱关联关系

软件设计类之间关系或者模块间强调：
高内聚(类里面的成员之间关联度很高)，低耦合(类和类之间关联度很低)，实际开发中，项目很大，需要多个人协作才能完成，比如张三和李四，张三维护的模块是A、B、C，李四维护的模块是D、E，高内聚的意思就是ABC三个模块之间需要联系紧密一些比较好，DE模块之间也是需要联系紧密一些比较好，而张三和李四维护的模块又需要关联度低一些，否则如果张三在修改一个模块时，李四的模块可能也收到了影响。

注意：

实际中，虽然组合比继承更好，但是也不是说，就不用继承，一般建议，需要清楚类和类之间的关系，如果类之间更符合is-a关系，建议用继承。如果类之间更符合has-a，建议用组合；如果不明确，既可以看作是is-a关系，也可以是has-a的关系，则用组合

Person和Student以及Person和Teacher构成is-a的关系：

  1. //Person和Student Person和Teacher构成is-a的关系
  2. class Person
  3. {
  4. protected:
  5.     string _name = "张三"; // 姓名
  6.     string _sex = "男"; // 性别
  7. };
  8. class Student : public Person
  9. {
  10. protected:
  11.     int _num;//学号
  12. };
  13. class Teacher : public Person
  14. {
  15. protected:
  16.     int _workID;//工号
  17. };

轮胎和车构成has-a关系：

  1. // Tire和Car构成has-a的关系
  2. class Tire
  3. {
  4. protected:
  5.     string _brand = "Michelin"; // 品牌
  6.     size_t _size = 17; // 尺寸
  7. };
  8. class Car
  9. {
  10. protected:
  11.     string _colour = "白色"; // 颜色
  12.     string _num = "陕ABIT00"; // 车牌号
  13.     Tire _t; // 轮胎
  14. };

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/attemptendeavor/article/details/122648841

内容来源于网络，如有侵权，请联系作者删除！

c++后端开发语言继承

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com