继承两三事

最新推荐文章于 2024-04-02 00:00:00 发布
原创 最新推荐文章于 2024-04-02 00:00:00 发布 · 460 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#继承 #cpp

本文深入讲解C++中的继承机制，包括基本概念、不同继承权限的特点、构造与析构函数的行为、作用域规则、赋值兼容规则等内容，并探讨了单继承、多继承、菱形继承及虚继承等高级主题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

C++中的继承，是C++三大特性之一，在其中占着非常重要的地位，今天，就让我们来说说继承。
一、基本概念
1.定义：继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能（用已存在的类来构建新类）。这样产生的新类称为派生类（子类），继承呈现了面向对象程序设计的层次结构，提高了程序的利用率以及代码的管理，大大提高了程序员的工作效率。
这里写图片描述
2.形式：class 派生类名：继承权限 基类名
继承权限：public、protected、private
3.继承的作用：实现代码复用以及多态。
4.类之间的关系：is_a（继承体现） has_a （组合关系）
5.如果不给出继承权限，则编译器默认为private继承关系
6.继承将给出除构造函数与析构函数外，将继承基类中的所有成员
7.基类的成员函数只能访问基类的成员，不能访问派生类中新增加的成员。
8.友元关系不能继承（因为友元函数不属于类中的成员函数，因此不能继承）
二、有关各种继承权限
公有继承（public）

class Base
{
public:
      int a;
protected:
      int b;
private:
      int c;
};
class Devided:public Base
{
public:
      void getum1()
      {
            cin >> _a >> "  " >> _b >> "  " >> _c ;
      }
      void display()
      {
            cout << a<<endl;
            cout << b << endl;
            cout << c << endl;
            cout << _a << endl;
            cout << _b << endl;
            cout << _c << endl;
            //总结：在派生类中不可以访问基类中的私有成员，公有继承条件下，其他成员均可以其在基类中的访问属性存在
      }
public:
      int _a;
protected:
      int _b;
private:
      int _c;
};
int main()
{
      Devided d;
      d._a = 1;//在类外可以访问公有继承中派生类的公有成员
      d.a = 2;//在类外可以访问公有继承下来中基类的公有成员
      //d.b = 3;//在类外不可以访问公有继承下来中基类的保护成员
      //d._b = 4;//在类外不可以访问公有继承中派生类中保护成员
      //d.c = 5;//在类外不可以访问公有继承下来中基类的私有成员
      //d._c = 6;//在类外不可以访问公有继承中派生类中的私有成员
      return 0;
}
//验证保护类成员，在公有继承之后仍为保护的访问属性,且在类外不能调用
class C :public Devided
{
      void displaynum()
      {
            cout << a << endl;
            cout << b << endl;
      }
};
int main()
{
      C c;
      c.b = 3;//不可访问
      return 0;
}

保护继承（protected）

class Base
{
public:
      int a;
protected:
      int b;
private:
      int c;
};
class Devided:protected Base
{
public:
      void getum1()
      {
            cin >> _a >> "  " >> _b >> "  " >> _c ;
      }
      void display()
      {
            cout << a<<endl;
            cout << b << endl;
            cout << c << endl;//私有成员不可访问
            cout << _a << endl;
            cout << _b << endl;
            cout << _c << endl;
            //总结：在派生类中不可以访问基类中的私有成员，保护成员继承下，其他成员的访问属性均变为protected访问属性，不可在类外访问
      }
public:
      int _a;
protected:
      int _b;
private:
      int _c;
};
int main()
{
      Devided d;
      d._a = 1;//在类外可以访问保护继承中派生类的公有成员
      d.a = 2;//在类外不可以访问保护继承下来中基类的公有成员
      d.b = 3;//在类外不可以访问保护继承下来中基类的保护成员
      d._b = 4;//在类外不可以访问保护继承中派生类中保护成员
      d.c = 5;//在类外不可以访问保护继承下来中基类的私有成员
      d._c = 6;//在类外不可以访问保护继承中派生类中的私有成员
      return 0;
}
//验证保护的继承方式:验证同上

私有继承（private）

class Base
{
public:
      int a;
protected:
      int b;
private:
      int c;
};
class Devided:private Base
{
public:
      void getum1()
      {
            cin >> _a >> "  " >> _b >> "  " >> _c ;
      }
      void display()
      {
            cout << a<<endl;
            cout << b << endl;
            cout << c << endl;//私有成员不可访问
            cout << _a << endl;
            cout << _b << endl;
            cout << _c << endl;
            //总结：在派生类中不可以访问基类中的私有成员，保护成员继承下，其他成员的访问属性均变为private访问属性，不可在类外访问
      }
public:
      int _a;
protected:
      int _b;
private:
      int _c;
};
int main()
{
      Devided d;
      d._a = 1;//在类外可以访问私有中派生类的公有成员
      d.a = 2;//在类外不可以访问私有继承下来中基类的公有成员
      d.b = 3;//在类外不可以访问私有继承下来中基类的保护成员
      d._b = 4;//在类外不可以访问私有继承中派生类中保护成员
      d.c = 5;//在类外不可以访问私有继承下来中基类的私有成员
      d._c = 6;//在类外不可以访问私有继承中派生类中的私有成员
      return 0;
}
//验证私有的继承方式:新创建一个类，在这个类中的基类的所有成员均不可访问

图示如下：
这里写图片描述
总结：1.基类的private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类派生类中能访问，就定义为protected。
2.public继承是一个接口继承，保持is_a原则，每个父类可用的成员对子类也可用，因为每个子类对象也都是一个父类对象。
3.protected\private继承是一个实现继承，基类的部分成员并非子类接口的一部分，是has_a的关系原则
4.不管是哪种继承方式，在派生类内部都可以访问基类的公有成员和保护成员，基类的私有成员存在，但在子类中不可见（不能访问）
5.使用关键字class时，默认的继承方式是private，使用struct时，默认的继承方式是public
三、派生类中的构造函数与析构函数
（一）构造函数

class A
{
public:
      A()
      {
            cout << "这是基类" << endl;
      }
      A(int a)
            :_a(a)
      {
            cout << "这是基类" << endl;
      }
      A(const A& a)
      {
            _a = a._a;
            cout << "这是基类" << endl;
      }
      A& operator=(const A& a)
      {
            cout << "A& operator=(const A& a)" << endl;
            cout << "这是基类" << endl;
            return *this;
      }
      ~A()
      {
            cout << "这是基类" << endl;
      }
private:
      int _a;
};
class B:public A
{
public:
      B()
      {
            cout << "这是派生类" << endl;
      }
      B(int b)
            :_b(b)
      {
            cout << "这是派生类" << endl;
      }
      B(const B& b)
      {
            _b = b._b;
            cout << "这是派生类" << endl;
      }
      B& operator=(const B& a)
      {
            cout << "B& operator=(const B& a)" << endl;
            cout << "这是派生类" << endl;
            return *this;
      }
      ~B()
      {
            cout << "这是派生类" << endl;
      }
private:
      int _b;
};
int main()
{
      B a;
      B b(10);
      B c;
      c = b;
      return 0;
}

这里写图片描述
由此可知，在调用派生类的构造函数之时，先调用的是基类的构造函数，从而完成对基类数据成员的初始化。
再进一步观察调用的反汇编
这里写图片描述
由上面也可知道，在继承中构造函数是不继承下来的。
说明：1.基类没有缺省的构造函数，派生类必须要在初始化列表中显示给出基类名和参数列表
2.基类没有定义构造函数，则派生类也可以不用定义，全部使用缺省构造函数（也可以是编译器自动合成的构造函数）
3.基类定义了带有形参表的构造函数，派生类就一定定义构造函数。
调用顺序：
这里写图片描述
（二）析构函数
代码同上
这里写图片描述
由此可以看出，在调用析构函数中，先调用派生类的析构函数，在调用基类的构造函数，这个恰好与构造函数的调用相反，与函数压栈出栈的顺序一致。
调用顺序：
这里写图片描述
四、继承体系中的作用域
1.在继承体系中基类和派生类是两个不同的作用域
2.子类和父类中有同名成员，子类成员将屏蔽父类成员的直接访问（在子类成员中可以使用 基类：：基类成员 访问）
3.注意在实际中在继承体系里面最好不要定义同名函数。

#include<iostream>
using namespace std;
class A
{
public:
      A(int a = 10, int b = 20)
            :_a(a)
            , _b(b)
      {}
      void display()
      {
            cout << _a << "  " << _b;
      }
private:
      int _a;
      int _b;
};
class B :public A
{
public:
      B(int c = 0)
      {
            _c = c;
      }
      void display()//发生同名隐藏
      {
            cout << _c;
      }
private:
      int _c;
};
int main()
{
      B b;
      b.display();
      return 0;
}

接下来看一下调用过程：
这里写图片描述
由上可以看出在调用相同名字的函数之时，往往会调用派生类中的函数，而将基类函数给隐藏掉，这也就是我们所说的同名隐藏。若要访问基类中的成员，则需要通过以下方法访问

b.A::display();

五、继承与转换—–赋值兼容规则—-（public继承）
先来看基类与派生类的对象模型
这里写图片描述
1.子类对象可以赋值给父类对象（切割\切片）：即在赋值之时，将派生类中基类成员只赋值给基类，将派生类中的自己特有成员以切片形式省略掉，
2.父类对象不能赋值给子类对象。原因：基类的对象只是派生类的一部分
3.父类的指针\引用可以指向子类对象
4.子类的指针\引用不能指向父类对象（可以通过强制类型转换）//强制类型转换，及其不安全，通过这种方法，扩大了父类的内存空间

#include<iostream>
using namespace std;
class A
{
public:
      A(int a = 10, int b = 20)
            :_a(a)
            , _b(b)
      {}
      void display()
      {
            cout << _a << "  " << _b;
      }
private:
      int _a;
      int _b;
};
class B :public A
{
public:
      B(int c = 0)
      {
            _c = c;
      }
      void display()//发生同名隐藏
      {
            cout << _c;
      }
private:
      int _c;
};
int main()
{
      A a;
      B b;
      a = b;//子类对象可以赋值给父类
      b = a;//错误
      A*pa = &a;//创建A类型的指针
      pa = &b;//利用A类型的对象，指向派生类的对象
      A&paa = a;//创建A类型的引用
      paa = b;//利用A类型的对象，指向派生类的对象
      b.display();
      b.A::display();
      return 0;
}

六、继承与静态成员

class A
{
public:
      A()
      {
            count++;
      }
public:
      static int count;
protected:
      int a;
};
class B:public A
{
protected:
      int b;
};
int A::count = 0;
class C :public A
{
protected:
      int c;
};
int main()
{
      A a1;
      A a2;
      A a3;
      B b;
      cout << "count=" << A::count << endl;
      cout << sizeof(B)<<endl;//8
      A::count = 0;
      cout << "count=" << A::count << endl;
      return 0;
}

这里写图片描述
基类定义了静态成员，则整个继承体系中只有一个这样的成员，无论派生出多少个子类，就只有一个static成员实例。
七、单继承&多继承&菱形继承
（一）单继承
模型
这里写图片描述
基本形式：

class A
{
protected:
      int a;
};
class B:public A
{
protected:
      int b;
};
class C :public B
{
protected:
      int c;
};

（二）多继承
模型
这里写图片描述
对象模型：
这里写图片描述
基本形式：

class A
{
protected:
      int a;
};
class B
{
protected:
      int b;
};
class C :public A,public B
{
protected:
      int c;
};

（三）菱形继承
模型：
这里写图片描述
对象模型：
这里写图片描述
基本形式：

class A
{
protected:
      int a;
};
class B:public A
{
protected:
      int b;
};
class C :public A
{
protected:
      int c;
};
class D :public B, public C
{
protected:
      int _d;
};

这里写图片描述

二义性问题

由上面的对象模型可以看出，菱形继承中有两份_a的数据，因此存在二义性与数据冗余的问题，想要解决这个问题，接下来将要引入虚继承的概念
八、虚继承–解决菱形继承的二义性和数据冗余的问题
关键字：virtual
形式
这里写图片描述
普通菱形继承：
这里写图片描述
虚继承：

class A
{
public:
      int a;
};
class B:virtual public A
{
public:
      int b;
};
class C :virtual public A
{
public:
      int c;
};
class D :public B, public C
{
public:
      int _d;
};
int main()
{
      D d;
      d.a = 1;//解决了数据的二义性问题
      d.b = 2;
      d.c = 3;
      d._d = 4;
      cout << sizeof(D) << endl;
      return 0;
}

这里写图片描述
相同代码，仅仅在使用了虚继承之后，所占用的内存反而多了4个字节，究竟是什么占用了这四个字节，现在我们来一探究竟。
这里写图片描述
由图中可以直观性的发现，在解决二义性的问题下，vs所使用的是偏移量表格，从而更好的解决这个问题。
总结：1. 虚继承解决了在菱形继承体系里面子类对象包含多份父类对象的数据冗余&浪费空间的问题。
2. 虚继承体系看起来好复杂，在实际应用我们通常不会定义如此复杂的继承体系。一般不到万不得已都不要定义菱形结构的虚继承体系结构，因为使用虚继承解决数据冗余问题也带来了性能上的损耗。

下面，再来谈下普通继承与虚继承之间的区别，从而让我们更好的理解与学习
区别：1.书写形式：虚拟关键字（virtual）
2.对象模型区别——>多了4个字节——>保存地址——>偏移量表格
这里写图片描述
3.对于继承成员访问形式
普通继承：直接访问
虚拟继承偏移量表格地址——>相对于基类对象的偏移量——>访问基类成员
4.构造函数不同
派生类——>合成构造函数——>将偏移量表格的地址放入对象的前4个字节中
构造函数多了一个参数——>push 1——>检测是否为虚拟继承

Java 继承复用避坑指南：五个血泪案例揭示高频陷阱
张彦峰的博客
05-11 3万+
本文系统剖析了继承滥用在实际系统中的五类典型陷阱，包括逻辑被绕过、构造失控、行为不一致、初始化混乱等问题，并通过真实业务案例与测试验证，逐一展示问题根源与演进优化方案。文章强调：继承是一把双刃剑，设计不慎将带来系统性隐患。 最终，我们总结出继承的适用边界，倡导以组合、接口、策略等手段替代非必要的继承，实现更健壮、可演进的业务架构。希望本文能为你在系统设计与代码演进中提供深度启发。
〖Python零基础入门篇㊲〗- 类的继承、多态与多重继承
热门推荐
易编橙 · 终身成长社群，相遇已是上上签！
03-12 4万+
什么是继承？在编程中继承的关系是类与类的一种关系。当我们定义了一个新的 类 时，可以从当前存在的 类 通过继承的关系得到其功能、属性等；被继承的 类 我们就叫做父类(也可以叫做基类或者超类)，而新的 类 则叫做子类，且其具备父类的功能、属性与一些特性。
C++继承中权限的影响
qq_48335434的博客
02-16 631
不同权限继承后的改变
【C++篇】权限对继承的影响
m0_66492811的博客
03-28 495
C++基础
C++继承（一）---继承中的访问权限
董皓宇
11-12 718
C++继承 继承的概念定义 概念 继承是面向对象语言中的一个重要方法，不是修改已存在的类，而是在该类的基础上将新的代码加入其中，并且实现之前类中的代码复用也是面向对象七大设计原则之一：组合/聚合复用原则。 继承呈现了面向对象语言的层次结构，体系拿了由简单到复杂的认知过程，继承是类设计层次的复用 语法格式 #include<iostream> using namespace std; ...
继承的作用，方式及各类继承的访问权限
m0_72305382的博客
01-31 614
2. 多继承：对于多继承来说，子类可以访问所有父类的公有属性和方法，但同样无法直接访问父类的私有属性和方法。总的来说，无论是哪种继承方式，子类都可以访问父类的公有属性和方法，但无法直接访问父类的私有属性和方法。4. 抽象类继承：子类可以访问抽象类中定义的公有方法和属性，同时也需要实现抽象类中定义的抽象方法。1. 代码复用：通过继承，子类可以继承父类的属性和方法，从而减少重复编写代码的工作量。1. 单继承：子类可以访问父类的公有属性和方法，但无法直接访问父类的私有属性和方法。这是最常见的继承方式。
什么是继承（一看就懂）
m0_65334415的博客
04-18 4258
目录 文章目录 前言 继承和派生： 一：继承的概念： 二：继承和派生 三：继承分类 四：继承方式： 五：继承方式总结语法 六：继承方式： 七：访问权限 八：代码举例：(继承时候的语法，继承权限的验证) 总结 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 继承简单点来说就是改造，拿原来的东西，原封不动的使用，然后自己添加东西，实现新的功能 继承和派生： 一：继承的概念： ..
C++继承
Wzs040810的博客
02-03 1736
C++继承
C++菱形继承对象内存布局实战讲解和分析
净无邪博客
02-27 2973
本文主要讲解C++对象模型中的菱形继承的对象模型，分别讨论基类对象变量和函数的继承问题。 何为菱形继承： 菱形继承是指一个基类（Base）派生出两个派生类（Derived1，Derived2），然后这两个派生类（Derived1，Derived2）派生出一个最终的派生类，如1.1的下图所示。 一、菱形继承之非虚继承 1.1类Base、派生类Derived1、派生类Derived2、最终派生类DDerived的UML结构图 1.2类Base、派生类Derived1、派生类Derived2、最终派生类DDer
Python学习之-继承和多态
最新发布
Summer的博客
04-02 3185
什么是继承？什么是多态？面向对象的三大特性：封装：根据 职责 将属性和方法封装到一个抽象类中继承： 实现代码的重用，相同的代码不需要重复的编写多态： 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度继承继承是一种机制，它使得一个类（称为子类或派生类）能够继承另一个类（称为父类或基类）的属性和行为（方法）。子类除了可以继承父类的功能外，还可以添加新的功能或重写某些功能。单继承: 当一个类仅继承自一个父类时。多继承: 当一个类继承自多个父类时。
继承的权限问题
a15929748502的博客
06-25 3942
首先什么是继承呢？ 继承的概念；继承机制是面向对象程序设计使代码可以复用的最重要的手段，他允许程序员在保持原有的类特性的基础上进行扩充，增加功能。这样产生了新的类，成为派生类，继承呈现了面对对象程序设计的层次结构，体现了由简单到复杂的认知过程。 这样来看我们就知道了继承的作用 1）实现代码复用 2）实现多态性 继承的格式是什么呢 ...
C\C++_继承_继承权限
qq_38255284的博客
01-09 781
一、继承权限的规则 继承权限类型 规则 备注 公有继承 私有继承 二、继承权限的用途 继承权限类型 作用 备注 公有继承 私有继承 私有继承可以使用has-a关系，但同时也会引发很多问题，而且较为抽象不易理解，通常应使用包含来建立has-a关系；如果新类需要访问原有类的保护成员，或需要重新定义虚函数，则应使用私有继承 参考书籍：c++ primer plus（第六版）——14.2.2 使用包含还是私有继承 ...
继承与权限控制
Thomas-yang的专栏
10-12 1243
Java中用于权限控制的有四个关键字：private,default,protected,public 。 private：类内部 default：类内部，同一个包 protected:类内部，同一个包，子类 public:所有的类 Java中用extends关键字表示子类对某一基类的继承。 下面看一个简单的例子： class Person{ private int a
5：继承的概念&权限修饰属性得继承
派大星
10-23 271
继承 继承是以一个类为父类，另一个类作为它的子类，子类在继承了父类的属性和方法的基础上，还可以进一步的拓展，例如增加或修改属性或方法 语法：在子类声明的地方加入extends [父类名]，也就是[Zilei] extends [父类名]; 当前子类，就拥有了父类的属性和方法,除了private属性方法除外，权限修饰符的作用再一次体现，仅在当前类中可被访问； 一个类只能继承一个父类，不能是多个类；...
继承的作用是什么？看看下面这些例子吧！
kaikeba的博客
11-23 2323
继承是面向对象编程技术的一块基石，因为它允许创建分等级层次的类。运用继承，你能够创建一个通用类，它定义了一系列相关项目的一般特性。 让我们看一个更实际的例子，该例子有助于阐述继承的作用。这样，新的类将包含一个盒子的宽度、高度、深度和重量。 // This program uses inheritance to extend Box. class Box { double width; double height; double depth; // construct clone of an
为目录设置继承权限。使用户读写执行的权限能够继承到子目录上。
qq_48492049的博客
08-12 768
答案 setfacl -d -m u:jack:rwx /tmp/zs(所谓继承子目录就是以后新创建的文件夹或文件) 未指定继承： 指定继承权限，没有指定某个人 指定某个人继承权限
C++权限继承方式对权限的影响
fullyanfmotr的博客
12-23 590
三种访问权限     public:可以被任意实体访问     protected:只允许子类及本类的成员函数访问     private:只允许本类的成员函数访问 注：当不写访问权限时默认为private 三种继承方式     public 继承       protect 继承     private 继承 注：当不写继承方式时默认为private 组合结果
C++继承详解：单继承与多继承
"C++继承是面向对象编程中的一个重要概念，它允许一个类（子类、派生类）从另一个类（基类、父类）那里继承特性与行为。这种机制使得代码重用变得简单，同时支持多态性。C++支持两种主要的继承方式：单一继承和多重...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值