自学内容网 自学内容网
自学内容网 > 正文

c++继承（万字详解、有图更直观易懂）

🕗 发布于 2024-11-11 22:56 c++  java  android  c语言  学习方法  

c++系列继承

文章目录

前言

由于这块内容比较重要，知识点较多，所以在一些地方比较啰嗦，请大家见谅！

一、继承的概念及定义

1.1、继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保
持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象
程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继
承是类设计层次的复用。例如在我们进行程序设计时，经常要对数据进行交换，我们一般都过调用定义的函数来完成这一操作（swap函数相信大家都写过），这就是函数级的复用，而继承是类层次的复用，他们本质都是抽取公共部分，方便随时使用，可以提高编写效率

接下来通过下面的需求来引入

如果我想定义一个类来存储，老师、学生的信息该怎么来完成的？
对于这个问题，相信都难不住大家，我们只需要知道他们，各自具有什么属性，就可以来实现。

老师：姓名、年龄、性别、身份证、职工号
学生：姓名、年龄、性别、身份证、学号、专业

我们可以看到，他们两个具有很多相同的属性，那么我们就可以将他们提取出来，定义Person（人）这个类来存储它，在我们需要的时候（定义学生、老师等类型时）拿出来用即可。

下面我们来看代码(简单看一下，后面会详细介绍)：
注：被继承（Person）的类一般称为基类（又叫父类)，继承的类被称派生类（又叫子类）。

class Person {//定义了一个父类
public:
string name ;//父类里面定义了一个string类型的和一个int类型
int age;
};
class Student:public Person{//定义了一个以public方式继承父类的子类student
public:
int _stuid;//在父类的name和age的基础上增加
int _major;
};

1.2、继承的定义

1.2.1、定义格式

下面我们看到Person是父类，也称作基类。Student是子类
在这里插入图片描述

到这里也就是，我们定义了一个新类（Student）并且以public(公有)继承方式继承了Person,那么我们就定义一个Student类型的对象看一下，对象存储的信息是什么。
在这里插入图片描述
在定义的s对象的内部存在一个Person类。

1.2.2、继承关系和访问限定符

在这里插入图片描述在这里插入图片描述

继承关系是可以省略不写的，如果我们不写，默认为private（私有继承）.

下面我们对继承方式和访问限定符的关系来讲解一下。
在这里插入图片描述

权限;public>protected>private

通过上面表格我们知道。
对于基类的公有成员：

  • 使用公有继承的方式，在派生类中是公有成员。
  • 使用保护继承的方式，在派生类中是保护成员。
  • 使用私有继承的方式，在派生类中是私有有成员。

对基类的保护成员：

  • 使用公有继承的方式，在派生类中是保护成员。

看到这里我想大家已经找到一些规律了，在继承过程中它会选取，基类成员访问权限和基类被继承方式这两者间，权限小的那个，作为基类成员在派生类中的访问权限。

在普通类中保护和私有成员都无法在类外访问，在这里他们还是有区别的，下面我们来讲一下不同权限，之间的区别(在派生类中).

class Person
{
//protected:
public:
    string _name="张三";
private:
    int _age=18;
};
//class Student : protected Person
//class Student : private Person
class Student : public Person
{
public:
    void Print()
    {
        cout << _name << endl;
    }
    int _stuid; // 学号
};
int main()
{
    Student s;
    s._name = "李四";
    s.Print();
    return 0;
}

public成员它在类内，类外都可以访问。
在这里插入图片描述

protected成员，它在类内可以访问，在类外无法访问。
在这里插入图片描述

private成员，在类内可以访问，在类外访问不可。

在这里插入图片描述
到这里又有人该问了，说了那么多，protected继承和private继承的区别，是什么呢？
大家想一想如果这里的派生类（Student）,作为另一个类的基类呢

继承的总结：

1.基类private成员无论以什么方式继承到派生类中都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2.基类private成员在派生类中不能被访问，如果基类成员不想在派生类外直接被访问，但需要在派生类中访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3.基类的私有成员在子类都是不可见；基类的其他成员在子类的访问方式就是访问限定符和继承方式中权限更小的那个（权限排序：public>protected>private）。
4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，但最好显式地写出继承方式。

二、子类和父类（基类和派生类）

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

在讲解之前，先理解下面这个
在这里插入图片描述

 string& s1= "abcde";
 const string& s2 = "abcde";

在c++中我们可以用一个double类型的数据赋值给int类型，这是因为他们存在隐式类型转换，而 int&c = b;报错，const int& d = b;这个没有，是因为在进行类型转换是，会用等号右侧值构造一个临时变量，然后用临时变量初始化等号左侧值，所以这里使用c引用的是那个临时变量，而临时变量具有常性，这就造成权限放大的问题，所以使用const修饰后的变量可以正确编译。对于自定义类型也是如此，大家可以用上面代码验证一下。

下面我们来看基类和派生类

代码：

class Person
{
public:
    string _name="张三";
    int _sex;
    int _age=18;
};
class Student : public Person
{
public:
    int _No; 
};

在这里插入图片描述
可以看到这里并不需要使用const来修饰，一样可以通过编译。所以这里并不会产生临时变量，它利用的是基类和派生类之间的赋值兼容规则（又叫做切割或切片）。

在这里插入图片描述

class Person
{
protected:
    string _name; 
    string _sex;// 性别
    int _age; // 年龄
};
class Student : public Person
{
public:
    int _No; // 学号
};
void Test()
{
    Student sobj;
    // 1.子类对象可以赋值给父类对象/指针/引用
    Person pobj = sobj;
    Person* pp = &sobj;
    Person& rp = sobj;

    //2.基类对象不能赋值给派生类对象
    sobj = pobj;
    // 3.基类的指针可以通过强制类型转换赋值给派生类的指针
    pp = &sobj;
    Student * ps1 = (Student*)pp; // 这种情况转换时可以的。
    ps1->_No = 10;
    pp = &pobj;
    Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
    ps2->_No = 10;
}

派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。
基类对象不能赋值给派生类对象。
基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类
的指针是指向派生类对象时才是安全的。大家可以验证一下。

三、继承中的作用域

在这里插入图片描述
c++规定同一作用域下，不可定义同名变量，从上面代码中，我们可以知道，在person类中存在变量_num存储身份证，在Student类中存在变量_num存储学号，而编译无异常，这就说明，这两个变量所属不同作用域。那么为什么打印结果是“999”而不是“111”呢？ 在程序编译是，编译器会优先在局部查找（Student类域内）如果找不到才会其他作用域。那么该怎么拿到person中的_num呢？看下面代码：

class Person
{
protected:
    string _name = "张三"; // 姓名
    int _num = 111; // 身份证号
  void Print()
 {
     cout << "Person "<< endl;
 }
};
class Student : public Person
{
public:
    void Print()
    {
        cout << " 身份证号:" << Person::_num << endl;
        cout << "Student" << endl;
    }
protected:
    int _num = 999; // 学号
};
int main()
{
    Student s1;
    s1.Print();return 0;
}

` 如果在派生类中想拿到，基类中的同名变量，我们只需要指定作用域（突破类域限制）来访问即可.
继续上述代码，如果类中出现同名函数，编译器是如何调用（在类外调用）的？
在这里插入图片描述
可以看到执行结果调用的是Student中的print函数，这是因为子类的print函数被隐藏了。

3.1、总结

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

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

为了让大家方便看，上面讲解使用的类都没定义成员函数，但是对于一些复杂的类，仅依靠编译器生成的默认成员函数是无法满足我们的需求的。
6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类
中，这几个成员函数是如何执行的呢？

class Person
{
protected:
    Person(const string& s = "张三")
        :_name(s)
    {
        cout << "person" << endl;
    }
    ~Person()
    {
        cout << "~Person" << endl;
    }
    string _name;
};
class Student : public Person
{
public:
    int _num; // 学号
};
int main()
{
    Student s1;
    return 0;
}

在这里插入图片描述
可以看到我们并没有创建person类型的对象，但是打印结果显示，person的构造和析构函数都执行了（这里是担心直接说出结论大家难以接受，另外几个构造函数一样的性质，大家可以自己验证，这里就不赘述类了）

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认
    的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
  3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能
    保证派生类对象先清理派生类成员再清理基类成员的顺序。
  5. 派生类对象初始化先调用基类构造再调派生类构造。
  6. . 派生类对象析构清理先调用派生类析构再调基类的析构。
    注：这里必须先调用派生类的析构，再调用基类析构，因为如果先调用基类析构，派生类部分可能会去访问基类部分数据，这将会造成野指针问题，而先析构派生类，基类部分的数据并不会访问派生类部分数据。
    在这里插入图片描述

这里需要重点强调一点，从上面的代码可以看到，当编译器默认生成的成员函数已经无法满足我们的需要，我们需要调用自定义的成员函数时，需要在派生类中显示调用，当显示调用析构函数时，会发现调用失败，这是因为编译器对析构函数进行了特殊处理（统一处理成destrutor（）,为后面多态做铺垫。下篇我会详细讲解），导致基类析构函数被隐藏。

五、继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员.
在这里插入图片描述

六、.继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子
类，都只有一个static成员实例（静态成员并不属于，某一个对象，它属于整个类，可以理解为派生类只是继承了基类对它的访问权限）。

这个不太重要，要是感兴趣可以自己测试一下，只需要定义变量，然后通过监视窗口，观察变量地址即可。

七、复杂的菱形继承及菱形虚拟继承

这部分了解即可，不需要掌握

单继承：一个子类只有一个直接父类时称这个继承关系为单继承
在这里插入图片描述
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

在这里插入图片描述
菱形继承：菱形继承是多继承的一种特殊情况。
在这里插入图片描述
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。
在Assistant的对象中Person成员会有两份。
在这里插入图片描述

class Person
{
public:
    string _name; // 姓名
};
class Student : public Person
{
protected:
    int _num; //学号
};
class Teacher : public Person
{
protected:
    int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
    string _majorCourse; // 主修课程
};
void Test()
{
    // 这样会有二义性无法明确知道访问的是哪一个
    Assistant a;
    a._name = "peter";
    // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
    a.Student::_name = "xxx";
    a.Teacher::_name = "yyy";
}

在这里插入图片描述

为方便讲解，我们接下来使用，下面简单电脑讲解

class A
{
public:
 int _a;
};
 class B : public A
//class B : virtual public A
{
public:
 int _b;
};
 class C : public A
//class C : virtual public A
{
public:
 int _c;
};
class D : public B, public C
{
public:
 int _d;
};
int main()
{
 D d;
 d.B::_a = 1;
 d.C::_a = 2;
 d._b = 3;
 d._c = 4;
 d._d = 5;
 //d.a=0;
 return 0;
 }

从内存角度看
在这里插入图片描述
大家结合代码看，可以看到D对象中存储了，两个_a变量，造成二义性问题。

为了解决二义性问题c++特意提供了一个关键字：virtual.

使用virtual是只需要在继承，产生二义性的基类时，使用virtual修饰即可，如下：
class B : virtual public A
class C : virtual public A（上面这部分被屏蔽了）

接下来我们直接在内存中看区别(如果新版编译器可能不太容易看到想看的内存)：
在这里插入图片描述
可以看到二义性的问题就解决了，那么多存的那个是声明呢？很显然它是一份地址，我们看一下地址中存的是什么。

在这里插入图片描述

内存以16进制显示，注意转换

这样就清晰多了，其实这里存储的是偏移量（以当前（B位置）为0位置向上偏移16个字节、以当前位置（c位置）开始向上偏移12字节），通过偏移量来找到_a变量。这样既解决了二义性问题，还不会影响类型间的转换（切割、切片）

这里再补充一点：

在这里插入图片描述
对于B类型的对象，也是使用偏移量来解决的，上面那个地址是用来干嘛的呢，这个我们在下一篇，多态再来介绍。


原文地址：https://blog.csdn.net/2301_80774875/article/details/143643674

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024