前言：

继承是是C++的三大特性之一，提高了代码的复用性，体现了结构的层次性。

继承的简单介绍

C++继承是面向对象编程中的核心概念之一，它允许开发者创建新的类（派生类），这些类继承现有类（基类）的属性和行为。通过继承，可以实现代码的重用，简化类的设计，并建立起类之间的层次结构。

特点

代码复用：派生类可以直接使用基类的属性和方法，无需重新编写。
层次结构：继承形成了类的层次结构，有助于组织和管理代码。
多态性：继承是实现多态的基础，允许同一接口有多种不同的实现。

继承

一、继承的定义格式

继承基本概念

class 派生类 : 继承方式 基类 {
   }

单继承

class <派生类名> : <继承方式> <基类名> {
   
    // 派生类新定义成员
};

多继承

class <派生类名> : <继承方式1> <基类名1>, <继承方式2> <基类名2>, ... {
   
    // 派生类新定义成员
};

二、继承类型

flowchart LR
访问限定符-->Pbulic
访问限定符-->Protected
访问限定符-->Private

flowchart LR
继承类型-->Pbulic
继承类型-->Protected
继承类型-->Private

C++支持三种类型的继承：

公有继承（Public）：这是最常用的继承类型，派生类可以访问基类的公有和受保护成员。
私有继承（Private）：派生类只能访问基类的私有成员，但这种继承在派生类的外部是不可见的。
受保护继承（Protected）：派生类可以访问基类的受保护和公有成员，但这些成员对于派生类的外部仍然是不可见的。

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

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

浮想关系：public > pritected > privatre
基类private成员： 在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。\
基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
关键字：class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
实际运用中 : 一般使用都是public继承，几乎很少使用protetced/private继承

四、基类在派生类中的赋值转换

定义下面的类，student继承person

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

class student:public person
{
   
public:
    void print()
    {
   
        cout << _age << " " << _name << " " << _id << " ";
    }
private:
    int _id;
};

如果执行：

// 1.子类对象可以赋值给父类对象/指针/引用
person p1 = d1;//通过
person* p2 = d1;
person& p3 = d1;
//2.基类对象不能赋值给派生类对象
d1 = p1;//编译失败

派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

---
title: 切片
---
classDiagram
Student --|>person:切除 _id
    Student : int _age    
    Student : string _name
    Student :int _id
    class person
    person : int _age
    person : string _name

五、继承的作用域

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

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

class student:public person
{
   
public:
    void print()
    {
   
        cout << _age << " " << _name << " " << _id << " ";//优先访问student子类成员
         cout << person::_age << " " << _name << " " << _id << " ";//可以指定类域
    }
private:
    int _age;
    int _id;
};

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

flowchart LR
默认成员函数-->构造和析构
默认成员函数-->拷贝构造和赋值重载
默认成员函数-->取地址重载

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类==没有==默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

//基类
class Person
{
   
public:
    Person(const char* name = "peter")//存在默认构造函数
        : _name(name)
    {
   
        cout << "Person()" << endl;
    }

private:
};
//派生类
class Student : public Person
{
   
public:
    Student(const char* name, int num)
        : Person(name)//类似匿名对象
        , _num(num)
    {
   
        cout << "Student()" << endl;
    }

protected:

    int _num; //学号

};

派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

//基类
class Person
{
   
public:
    Person(const Person& p)
        : _name(p._name)
    {
   

            cout << "Person(const Person& p)" << endl;
    }
protected:
    string _name; // 姓名
};
//派生类
class student : public Person
{
   
public:
    Student(const Student& s)
        : Person(s)//显示调用
        , _num(s._num)
    {
   
        cout << "Student(const Student& s)" << endl;
    }
protected:
    int _num; //学号
};

派生类的operator=必须要调用基类的operator=完成基类的复制。

//基类
class Person
{
   
public:
    Person& operator=(const Person& p)
    {
   
        cout << "Person operator=(const Person& p)" << endl;
        if (this != &p)
            _name = p._name;

        return *this;
    }

protected:
    string _name; // 姓名
};
//派生类
class student : public Person
{
   
public:
    Student& operator = (const Student& s)
    {
   
        cout << "Student& operator= (const Student& s)" << endl;
        if (this != &s)
        {
   
            Person::operator =(s);//显示调用，并且指定类域
            _num = s._num;
        }
        return *this;
    }
protected:
    int _num; //学号
};

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

//基类
class Person
{
   
public:
    ~Person()
    {
   
        cout << "~Person()" << endl;
    }

protected:
    string _name; // 姓名
};
//派生类
class student : public Person
{
   
public:
    ~Student()
    {
   
        cout << "~Student()" << endl;
    }

protected:
    int _num; //学号
};

小结

派生类对象初始化先调用基类构造再调派生类构造。
派生类对象析构清理先调用派生类析构再调基类的析构。
因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同，那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加 virtual的情况下，子类析构函数和父类析构函数构成隐藏关系

七、继承和友元和静态

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

八、菱形继承和虚拟继承

单继承

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

B继承A，C继承B

flowchart LR
chass_A-->classB-->class_C

多继承

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

C继承A和B

flowchart TD
class_A-->class_C
class_B-->class_C

菱形继承

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

B和C继承A，B和C继承D

flowchart TD
class_A-->class_B
class_A-->class_C
class_B-->class_D
class_C-->class_D

//A类
class A
{
   
public:
    int _a;
};
//B类继承A
class B : public A
{
   
public:
    int _b;
};
//C类继承A
class C : public A
{
   
public:
    int _c;
};
//D类继承B和C
class D:public B,public C
{
   
public:
    int _d;
};

这个是一个菱形继承，菱形继承会引出很多问题。

如果这样访问，会产生==数据冗余和二义性==

D d1;
d1._a = "hello";//这样会有二义性无法明确知道访问的是哪一个
//这样访问虽然说解决了二义性，但是不可避免数据冗余
d1.B::_a = "hello";
d1.C::_a = "hello";

解决方法：

在菱形继承中，应当在中间派生类（即那些共享同一个基类的派生类）的继承声明中使用virtual关键字，将共同继承的基类标记为虚拟继承。
最终派生类中只会包含一份基类的数据成员和函数，解决了数据冗余与二义性问题。

注意：

虚继承只发生在最顶层的派生类中，而不会在派生类的派生类中发生。
虚继承会在内存布局中引入额外的指针（虚表指针）来维护虚拟继承的关系。
虚继承可能会略微增加程序的复杂性，因为需要处理虚指针和虚基类表。

int main()
{
   
    D d;                   //内存
    d.B::_a = 1;           //0x00000094A42FFB08  01 00 00 00  ....
    d.C::_a = 2;          //0x00000094A42FFB0C  03 00 00 00  ....
    d._b = 3;             //0x00000094A42FFB10  02 00 00 00  ....
    d._c = 4;             //0x00000094A42FFB14  04 00 00 00  ....
    d._d = 5;             //0x00000094A42FFB18  05 00 00 00  ....
    return 0;
}

在这里插入图片描述

在这图中我们发现数据冗余

虚拟继承的示例：

//A类
class A
{
   
public:
    int _a;
};
//B类继承A
class B : virtual public A
{
   
public:
    int _b;
};
//C类继承A
class C : virtual public A
{
   
public:
    int _c;
};
//D类继承B和C
class D:public B,public C
{
   
public:
    int _d;
};

在这里插入图片描述

这里是通过了B和C的两个指针，指向的一张表。
这两个指针叫虚基表指针，这两个表叫虚基表。
虚基表中存的偏移量。通过偏移量可以找到下面的A。

0x000000B1C3CFFBD8  20 ac d5 31 f6 7f 00 00   ??1?... //B类，虚基表指针 28
0x000000B1C3CFFBE0  03 00 00 00 cc cc cc cc  ....???? //B类
0x000000B1C3CFFBE8  28 ac d5 31 f6 7f 00 00  (??1?... //C类，虚基表指针 20
0x000000B1C3CFFBF0  04 00 00 00 cc cc cc cc  ....???? //C类
0x000000B1C3CFFBF8  05 00 00 00 cc cc cc cc  ....???? //D类
0x000000B1C3CFFC00  02 00 00 00 cc cc cc cc  ....???? //A类 
//计算方法                                              
//0x000000B1C3CFFBD8 减去 0x000000B1C3CFFC00  等于28 偏移量
//0x000000B1C3CFFBE8 减去 0x000000B1C3CFFC00  等于20 偏移量

九、继承和组合

继承（Inheritance）

继承是一种"is-a"关系，它允许一个类（派生类）继承另一个类（基类）的属性和行为。通过继承，派生类可以重用基类的代码，并可以添加新的特性或覆盖基类中的某些行为。继承的特点包括代码重用、层次结构的创建和多态性。然而，过度使用继承可能导致类层次结构复杂化，破坏封装性，并增加类之间的耦合度。（白箱复用）

组合（Composition）

组合是一种"has-a"或"contains-a"关系，它表示一个类（组合类）包含另一个类（成员类）的对象作为其成员。组合类通过包含成员类的对象来使用成员类的功能，并且对成员类的对象具有完全的控制权。组合提供了更低的耦合度，因为它允许在运行时动态地改变成员对象，提供了更大的灵活性。此外，组合有助于保持类的封装性，因为成员类的内部细节对外部是不可见的(黑箱复用)

//继承
class A
{
   
public:
    int _a;
};
class B : public A
{
   
public:
    int _b;
};
//组合
class A
{
   
public:
    int _a;
};
class B : 
{
   
public:
    A a();
    int _b;
};

注意：

实际尽量多去用组合。组合的耦合度低，代码维护性好。
继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。
类之间的关系可以用继承，可以用组合，就用组合。
组合（Composition）

//继承
class A
{
   
public:
    int _a;
};
class B : public A
{
   
public:
    int _b;
};
//组合
class A
{
   
public:
    int _a;
};
class B : 
{
   
public:
    A a();
    int _b;
};

注意：

实际尽量多去用组合。组合的耦合度低，代码维护性好。
继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。
类之间的关系可以用继承，可以用组合，就用组合。

【C++】继承

前言：

继承的简单介绍

特点

继承

一、继承的定义格式

二、继承类型

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

四、基类在派生类中的赋值转换

五、继承的作用域

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

小结

七、继承和友元和静态

八、菱形继承和虚拟继承

单继承

多继承

菱形继承

解决方法：

九、继承和组合

继承（Inheritance）

组合（Composition）

注意：

组合（Composition）

注意：

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【C++】继承

前言：

继承的简单介绍

特点

继承

一、继承的定义格式

二、继承类型

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

四、基类在派生类中的赋值转换

五、继承的作用域

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

小结

七、继承和友元和静态

八、菱形继承和虚拟继承

单继承

多继承

菱形继承

解决方法：

九、继承和组合

继承（Inheritance）

组合（Composition）

注意：

组合（Composition）

注意：

热门文章

最新文章

相关课程

相关电子书

相关实验场景