【C++练级之路】【Lv.12】继承(你真的了解菱形虚拟继承吗?)

简介: 【C++练级之路】【Lv.12】继承(你真的了解菱形虚拟继承吗?)

一、继承的概念及定义

1.1 继承的概念

继承(inheritance),是面向对象的三大特性之一。


它是面向对象编程中,使代码可以复用的最重要的手段,它允许程序员保持原有类特性的基础上进行扩展,增加功能,这样产生新的类。


之前我们接触的复用,都是函数设计层面的复用,而继承则是类设计层面的复用,体现了由简单到复杂的认知过程。

1.2 继承的定义

举个例子,一个Student类继承一个Person类:

class Person
{
protected:
  string _name;
  int _age;
};

class Student :public Person
{
protected:
  int _stuid;
};
  • 此时,Person类称为基类(父类),Student类称为派生类(子类)
  • 继承方式为public(公有)继承

1.3 继承方式和访问限定符

之前介绍访问限定符,没有详细介绍protected,是因为到了继承,protected才和private有所区别。

image.png

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

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

细节:

  1. public和protected成员,对于任何继承,永远是取二者的较小范围(public > protected > private)
  2. private成员比较特殊,无论任何继承,都不可见(派生类对象无论在类内,还是类外,都无法访问继承的private成员)
  3. 使用关键字class时默认的继承方式是private,使用struct时默认的继承方式是public,不过最好显式写出继承方式

值得一提的是,正因private成员在派生类中不可见,所以想要基类成员不被类外访问,却能在派生类中访问,则使用protected限定符。

同时,在实际运用中一般使用都是public继承,几乎很少使用protetced/private继承,也不提倡使用protetced/private继承,因为protetced/private继承下来的成员都只能在派生类的类里面使用,实际中扩展维护性不强。

二、基类和派生类对象赋值转换

class Person
{
protected:
  string _name;
  string _sex;
  int _age;
};

class Student : public Person
{
public:
  int _No; // 学号
};
  1. 派生类对象可以赋值给 基类的对象/基类的指针/基类的引用(称为切片或切割)
Student sobj;
// 1.子类对象可以赋值给父类对象/指针/引用
Person pobj = sobj;
Person* pp = &sobj;
Person& rp = sobj;

  1. 基类对象不能赋值给派生类对象
//2.基类对象不能赋值给派生类对象
sobj = pobj;//err
  1. 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。

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

// 3.基类的指针可以通过强制类型转换赋值给派生类的指针
pp = &sobj;
Student * ps1 = (Student*)pp; //这种情况转换时可以的。
ps1->_No = 10;

pp = &pobj;
Student* ps2 = (Student*)pp; //这种情况转换时虽然可以,但是会存在越界访问的问题
ps2->_No = 10;

三、继承中的作用域

  1. 在继承体系中基类和派生类都有独立的作用域。
  2. 子类和父类中有同名成员,子类成员将屏蔽父类对同名成员的直接访问,这种情况叫隐藏,也叫重定义。(在子类成员函数中,可以使用 基类::基类成员 显示访问)
  3. 如果是成员函数的隐藏,只要函数名相同就构成隐藏。

注意:在实际中在继承体系里面最好不要定义同名的成员

举个例子:

class A
{
public:
  void fun()
  {
    cout << "func()" << endl;
  }
};

class B : public A
{
public:
  void fun(int i)
  {
    A::fun();
    cout << "func(int i)->" << i << endl;
  }
};
  • B中的fun和A中的fun不是构成重载,因为不是在同一作用域
  • B中的fun和A中的fun构成隐藏,成员函数满足函数名相同就构成隐藏。

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

先给出基类的默认成员函数:

class Person
{
public:
  Person(const char* name = "peter")
    : _name(name)
  {}

  Person(const Person& p)
    : _name(p._name)
  {}

  Person& operator=(const Person& p)
  {
    if (this != &p)
      _name = p._name;

    return *this;
  }

  ~Person()
  {}
protected:
  string _name;
};

class Student : public Person
{
public:
protected:
  int _num; //学号
};

4.1 构造函数

  • 派生类的构造函数必须调用基类的构造函数初始化基类继承的成员(如果基类没有默认的构造函数,则必须在派生类构造函数的初始化列表阶段显式调用)
  • 派生类对象初始化先调用基类构造再调派生类构造
Student(const char* name, int num)
  : Person(name)
  , _num(num)
{}

4.2 拷贝构造函数

  • 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化
Student(const Student& s)
  : Person(s)
  , _num(s._num)
{}

4.3 赋值重载函数

  • 派生类的operator=必须要调用基类的operator=完成基类的赋值
Student& operator=(const Student& s)
{
  if (this != &s)
  {
    Person::operator=(s);
    _num = s._num;
  }
  return *this;
}

4.4 析构函数

  • 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。
  • 基类析构函数不加virtual的情况下(关于多态:析构函数在某些场景下需要重写,编译器会对析构函数名进行特殊处理,处理成destrutor()),派生类析构函数和基类析构函数构成隐藏关系
~Student()
{}

五、继承与友元

友元关系不能继承,也就是说基类友元不能访问派生类protected和private成员。

六、继承与静态成员

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

以下代码利用这个性质,可以统计人的个数:

class Person
{
public:
  Person() { ++_count; }
protected:
  string _name; // 姓名
public:
  static int _count; // 统计人的个数。
};
int Person::_count = 0;

class Student : public Person
{
protected:
  int _stuNum; // 学号
};

class Graduate : public Student
{
protected:
  string _seminarCourse; // 研究科目
};

七、菱形继承及虚拟继承

7.1 菱形继承

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


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


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

菱形继承的问题:从下面的对象成员模型构造,可以看出菱形继承有数据冗余和二义性的问题。

在Assistant的对象中Person成员会有两份。

7.2 虚拟继承

7.2.1 解决方法

为了解决菱形继承出现的数据冗余和二义性,出现了虚拟继承。如上面的继承关系,在Student和Teacher的继承Person时使用虚拟继承,即可解决问题。

使用虚拟继承时,在继承方式前加上virtual关键字:

class Person
{
public:
  string _name; // 姓名
};

class Student : virtual public Person
{
protected:
  int _num; //学号
};

class Teacher : virtual public Person
{
protected:
  int _id; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected:
  string _majorCourse; // 主修课程
};

void Test()
{
  Assistant a;
  a._name = "peter";
}

需要注意的是,虚拟继承不要在其他地方去使用。

7.2.2 原理

在菱形虚拟继承中:

  • Assistant的对象中Person成员只存在一份,并且存在于对象的最底部
  • Student和Teather部分会存在各自的指针,该指针(虚基表指针)指向一份表(虚基表),其中记录了各自相对于Person部分偏移量(通过偏移量就能找到下方的Person部分)

八、继承的总结与反思

  1. 尽量少用多继承,一定不要设计出菱形继承,否则在复杂度及性能上都有问题。
  2. 多继承可以认为是C++的缺陷之一,很多后来的OO语言都没有多继承,如Java。
  3. 继承与组合
  • public继承是一种is-a的关系。每个派生类对象都是一个基类对象。
  • 组合是一种has-a的关系。假设B组合了A,每个B对象中都有一个A对象。
  • 优先使用对象组合,而不是类继承。组合的耦合度低,代码维护性好。不过继承也有用武之地的,有些关系就适合继承那就用继承,另外要实现多态,也必须要继承。
class A
{
public:
  int _a;
};

class B : public A
{
public:
  int _b;
};

class C
{
public:
  int _c;
};

class D
{
public:
  int _d;
  C _cc;
};

上述代码,A和B是继承关系,而C和D是组合关系。


几道面试题:

  1. 什么是菱形继承?菱形继承的问题是什么?
  2. 什么是菱形虚拟继承?如何解决数据冗余和二义性的?
  3. 继承和组合的区别?什么时候用继承?什么时候用组合?


真诚点赞,手有余香


目录
打赏
0
0
0
0
14
分享
相关文章
|
1月前
|
C++学习之继承
通过继承,C++可以实现代码重用、扩展类的功能并支持多态性。理解继承的类型、重写与重载、多重继承及其相关问题,对于掌握C++面向对象编程至关重要。希望本文能为您的C++学习和开发提供实用的指导。
59 16
【C++面向对象——继承与派生】派生类的应用(头歌实践教学平台习题)【合集】
本实验旨在学习类的继承关系、不同继承方式下的访问控制及利用虚基类解决二义性问题。主要内容包括: 1. **类的继承关系基础概念**:介绍继承的定义及声明派生类的语法。 2. **不同继承方式下对基类成员的访问控制**:详细说明`public`、`private`和`protected`继承方式对基类成员的访问权限影响。 3. **利用虚基类解决二义性问题**:解释多继承中可能出现的二义性及其解决方案——虚基类。 实验任务要求从`people`类派生出`student`、`teacher`、`graduate`和`TA`类,添加特定属性并测试这些类的功能。最终通过创建教师和助教实例,验证代码
57 5
【C++】继承
C++中的继承是面向对象编程的核心特性之一,允许派生类继承基类的属性和方法,实现代码复用和类的层次结构。继承有三种类型:公有、私有和受保护继承,每种类型决定了派生类如何访问基类成员。此外,继承还涉及构造函数、析构函数、拷贝构造函数和赋值运算符的调用规则,以及解决多继承带来的二义性和数据冗余问题的虚拟继承。在设计类时,应谨慎选择继承和组合,以降低耦合度并提高代码的可维护性。
44 1
【C++】继承
|
4月前
|
C++
C++番外篇——对于继承中子类与父类对象同时定义其析构顺序的探究
C++番外篇——对于继承中子类与父类对象同时定义其析构顺序的探究
77 1
C++的忠实粉丝-继承的热情(1)
C++的忠实粉丝-继承的热情(1)
36 0
【C++篇】深度解析类与对象(下)
在上一篇博客中,我们学习了C++的基础类与对象概念,包括类的定义、对象的使用和构造函数的作用。在这一篇,我们将深入探讨C++类的一些重要特性,如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象,以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念,提升代码的健壮性、灵活性和可维护性。
【C++篇】深度解析类与对象(中)
在上一篇博客中,我们学习了C++类与对象的基础内容。这一次,我们将深入探讨C++类的关键特性,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载、以及取地址运算符的重载。这些内容是理解面向对象编程的关键,也帮助我们更好地掌握C++内存管理的细节和编码的高级技巧。
【C++篇】深度解析类与对象(上)
在C++中,类和对象是面向对象编程的基础组成部分。通过类,程序员可以对现实世界的实体进行模拟和抽象。类的基本概念包括成员变量、成员函数、访问控制等。本篇博客将介绍C++类与对象的基础知识,为后续学习打下良好的基础。
|
1月前
|
【C++面向对象——类与对象】Computer类(头歌实践教学平台习题)【合集】
声明一个简单的Computer类,含有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等,以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制,用于保护类的数据不被外部随意修改。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。成员可以在派生类(继承该类的子类)中访问。成员,在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务,你需要掌握。
71 19
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等