C++的继承

已于 2023-04-14 23:16:25 修改
阅读量222 收藏
点赞数
文章标签： c++
于 2023-04-14 23:10:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_67017963/article/details/130117382
版权

文章目录

前言

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

例如：创建一个面向学生老师保安食堂阿姨等等角色的类，而姓名，年龄，地址，性别，这些是每一个人都会有的信息，我们可以做为一个基类，来给不同的角色继承，再追加一些职业信息等等数据，以些产生新的派生类。

一、继承的定义

#include <iostream>
#include <string>

using namespace std;
//这是一个基类，里面包含了姓名，年龄
class Person
{
public:
    void print()
    {
        cout << _age << endl;
        cout << _name << endl;
    }
private:
    int _age = 18;//我们给缺省值
    string _name = "jack";
    
};
//这是一个继承了Person的派生类，除了有Person类的成员和函数外，另外增加了一个工号
class Teacher : public Person
{
private:
    int _jobid;//工号
};
//这是一个继承了Person的派生类，除了有Person类的成员和函数外，另外增加了一个学号
class Student : public Person
{
private:
    int _stuid;//学号
};

int main()
{
    Student s;
    Teacher t;
    
    s.print();
    t.print();
    return 0;
}

输出结果
在这里插入图片描述

继承后基类的Person的成员（成员函数+成员变量）都会变成派生类的一部分。这里体现出了Student和Teacher复用了Person的成员。调用Print可以看到成员函数的复用。

二、继承关系

在这里插入图片描述

在这里插入图片描述

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

三、派生类与基类的赋值对象转换

  1. 派生类因为继承了基类，所以天生对基类，有亲近关系，派生类对象可以直接赋值给基类的对象/基类的指针/基类的引用。
  2. 但是基类不能赋值给派生类。
#include <iostream>
#include <string>

using namespace std;
class Person
{
public:
    Person()
    {
        
    }
    Person(const string& name,const int& age)
    :_name(name)
    ,_age(age)
    {

    }
    void print()
    {
        cout << _age <<' '<<_name << endl;
    }
private:
    int _age;
    string _name;
    
};

class Student : public Person
{
public:
    Student(const string& name,const int& age,const int& stuid)
    :Person(name,age)
    ,_stuid(stuid)
    {

    }
private:
    int _stuid;//学号
};

int main()
{
    //派生类
    Student s("张三",18,2200);
    //派生类可以直接赋值给基类
    Person t = s;
    
    t.print();
    s.print();
    
    //派生类可以赋值给基类的指针/引用
    Person* ptr = &s;
    Person& pp = s;
    
    //基类不能赋值给派生类
    //s = t;
    
    //这种情况是可以通过，强制转换，来赋值的
    ptr = &s;
    Student* ptrS = (Student*) ptr;
    return 0;
}

输出结果
在这里插入图片描述

相当于，把派生类的 ，属于基类的对象，进行赋值。

在这里插入图片描述

四、继承的作用域

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

using namespace std;
class A
{
public:
    void print()
    {
        cout << _name << endl;
    }
    string _name = "李四";
};

class B : public A
{
public:
    void print()
    {
        cout << _name << endl;
    }
    string _name ="张三";
};

int main()
{
    B b;
    //默认访问自身类的成员
    cout << b._name << endl;
    //也可以通过指定类域访问成员
    cout << b.A::_name<< endl;
    //同名的成员函数，由于不在同一个作用域，不构成重载，构成隐藏，默认访问自身类的成员函数
    b.print();
    //如果要访问基类的同名成员函数，需要通过指定域来访问
    b.A::print();
    return 0;
}

输出结果
在这里插入图片描述

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

6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

#include <iostream>
using namespace std;

class A
{
public:
	//构造函数
    A()
    {
        cout << "A()" << endl;
    }
    //析构函数
    ~A()
    {
        cout << "~A()" << endl;
    }
};

class B : public A
{
public:
	//构造函数
    B()
    {
        cout << "B()" << endl;
    }
    //派生类的析构和基类的析构，默认是隐藏关系
    //如果要调用必须指定作用域，以A::～A()为例;
    //派生类的析构函数，完成后，会默认调用基类的析构函数
    //不需要我们显示调用基类析构函数
    ~B()
    {
        cout << "~B()" << endl;
    }
};

int main()
{
    B b;
    return 0;
}

输出结果
在这里插入图片描述

派生类，会默认先调用基类的构造函数，再调自身的构造函数，而析构的顺序是反的，派生类会先调用自身的析构函数，再调用基类的析构函数。

#include <iostream>
#include <string>
using namespace std;
class A
{
public:
    A(const string& name)
    :_name(name)
    {
        
    }
protected:
    string _name;
};

class B : public A
{
public:
    B(const string& name,const int& jobid)
    //显式调用基类的构造函数
    :A(name)
    ,_jobid(jobid)
    {
        
    }
    void print()
    {
        cout << A::_name <<' '<<_jobid << endl;
    }
protected:
    int _jobid;
};

int main()
{
    B b("张三",22001);
    b.print();
    return 0;
}

输出结果
在这里插入图片描述

对基类的初始化，必须是调用基类的构造函数完成。

#include <iostream>
#include <string>

using namespace std;
class A
{
public:
    A(const string& name)
    :_name(name)
    {
        
    }
    A(const A& ra)
    :_name(ra._name)
    {
        
    }
    A& operator=(const A& ra)
    {
        if(&ra != this)
        {
            _name = ra._name;
        }
        return *this;
    }
protected:
    string _name;
};

class B : public A
{
public:
    B(const string& name,const int& jobid)
    //显式调用基类的构造函数
    :_jobid(jobid)
    ,A(name)
    {
        
    }
    B(const B& rb)
    //对于拷贝构造，要调用基类的拷贝构造，由于B继承了A，天生对A亲近，所以可以
    //直接把B传递给A进行拷贝构造属于A的成员
    :A(rb)
    ,_jobid(rb._jobid)
    {
        
    }
    B& operator=(const B& rb)
    {
        if(&rb != this)
        {
            _jobid = rb._jobid;
            //赋值重载，则直接调用基类的赋值重载，由于B继承了A，天生对A亲近
            //可以直接把B传递给A，调用A的赋值重载
            A::operator=(rb);
        }
        return *this;
    }
    void print()
    {
        cout << A::_name <<' '<<_jobid << endl;
    }
protected:
    int _jobid;
};

int main()
{
    B b("张三",22001);
    b.print();
    
    //拷贝构造
    B bb(b);
    bb.print();
    return 0;
}

输出结果
在这里插入图片描述

派生类的operator=必须要调用基类的operator=完成基类的复制。，派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

六、派生类不继承基类的友元

也就是说基类友元不能访问派生类私有和保护成员，如果需要继承，同样在派生类中，声明友元。

#include <iostream>
#include <string>

using namespace std;

class Student;
class Person
{
    //友元
    friend void Display(const Person& p,const Student& s);
protected:
    string _name = "张三";
};

class Student
{
    //友元
    friend void Display(const Person& p,const Student& s);
protected:
    int _stuNum = 22001;
};


void Display(const Person& p,const Student& s)
{
    cout << "姓名："<< p._name << endl;
    cout << "学号：" << s._stuNum << endl;
}

int main()
{
    Person p;
    Student s;
    Display(p, s);
    return 0;
}

输出结果
在这里插入图片描述

七、继承与静态成员

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

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
    static int _count;//统计人数
};
int Person :: _count = 0;

class Student : public Person
{
public:
    Student()
    {
        _count++;
    }
protected:
    int _stuNum ; // 学号
};

class Graduate : public Person
{
public:
    Graduate()
    {
        _count++;
    }
protected:
    string _seminarCourse ; // 研究科目
};

int main()
{
    Student s;
    Graduate g;
    
    cout << "人数:" << s._count << endl;
    cout << "人数:" << g._count << endl;
    cout << "_count地址:" << &s._count << endl;
    cout << "_count地址:" << &g._count << endl;
    return 0;
}

输出结果

Student和Graduate派生类，都继承了基类Person，但是student和graduate去访问基类的静态成员时，两个派生类所访问的是同一个成员，地址也是相同的，这是因为静态成员，所存储的地方是静态区，所以造就了，两个派生类，所访问的同一个成员现象。

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

单继承：一个子类只有一个直接父类时称这个继承关系为单继承
在这里插入图片描述
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
在这里插入图片描述
菱形继承：菱形继承是多继承的一种特殊情况。

在这里插入图片描述

在这里插入图片描述

#include <iostream>
using namespace std;

class A
{
public:
    int _a;
};

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

class C : public A
{
public:
    int _c;
};

class D : public B,public C
{
public:
    int _d;
};

int main()
{
    D d;
    d._b = 1;
    d._c = 2;
    d.B::_a = 3;
    d.C::_a = 4;
    d._d = 5;
    return 0;
}

我们可以通过监视窗口更容易看清楚，A的成员_a是有两份的，这会造成代码的二义性和数据冗余的问题。

在这里插入图片描述

C++为了解决这一情况，从而有了一个新的关键词，virtual，简称虚拟继承，解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在B和C的继承A时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。

#include <iostream>
using namespace std;

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._b = 1;
    d._c = 2;
    d.B::_a = 3;
    d.C::_a = 4;
    d._d = 5;
    return 0;
}

在B继承A时 加关键字 virtual
同时C继承A时也加关键字virtual，这里D再同时继承B和C时，编译器会处理成，A的继承会变成虚拟继承，同时D在访问_a时，只会有一个成员，而B和C里面的_a成员保存的不是_a，而是对_a的地址偏移量，最终都是指向同一个_a。

在这里插入图片描述

继承总结

组合

组合的权限是public大家能访问的，我也能访问，protected和private大家不能访问的，我也不能访问

class A
{
protected:
    int _a;
};
//组合方式
class B
{
public:
    A a;
    int _b;
};

继承方式

继承的是public大家能访问的， 我也能访问，protected和private的大家不能访问，但protected我能访问。

class A
{
protected:
    int _a;
};
//继承方式
class C : public A
{
public:
    int _c;
};

继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复
用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。

组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。

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

思考题

  1. 什么是菱形继承？菱形继承的问题是什么？
  2. 什么是菱形虚拟继承？如何解决数据冗余和二义性的
  3. 继承和组合的区别？什么时候用继承？什么时候用组合？
m0_67017963
关注
C++ — 继承
木头的博客
07-26 328
继承的基本概念 继承(inheritance)机制 是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在 保持原有类特性的基础上进行扩展 ，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 继承的定义 //基类 class Person { }; //派生类 //class...
C++继承
Wzs040810的博客
02-03 1696
C++继承
【C++】静态函数的继承
08-16 841
代码】【C++】静态函数的继承。
C++面试题：静态成员函数能不能被继承？
最新发布
CppPlayer
03-04 530
虚函数表保存着类的虚函数地址，程序运行时，基类或派生类的指针或引用会根据对象的实际类型（而不是声明的类型）来调用对应的虚函数版本。静态成员函数对比普通函数有点特殊，静态成员函数是属于类本身的，而不是类的对象。所以静态成员函数不参与多态：静态成员函数的调用是通过类本身而不是通过对象进行的，因此不涉及动态绑定。因为静态成员函数和类的实例无关，它们是与类本身绑定的，而不是和对象的状态绑定。静态成员函数可以被继承：派生类可以继承基类的静态成员函数，但静态函数本身与对象无关，不能在派生类中重写。
8.9作业
m0_74789986的博客
08-09 234
2.搭建一个货币的场景，创建一个名为 RMB 的类，该类具有整型私有成员变量 yuan（元）、jiao（角）和 fen（分），并且具有以下功能：
【C++】继承（三）--友元，静态函数，组合
ly_6699的博客
03-27 379
继承（一）：https://blog.youkuaiyun.com/ly_6699/article/details/88801492 继承（二）：https://blog.youkuaiyun.com/ly_6699/article/details/88805464 今天，我们接着前两天的内容继续讲继承。 本节内容主要有 继承和友元，继承和静态函数，继承和组合 5.继承和友元 这里只需要注意一点，友元关系不能继承！ 也就...
C++ 继承详解及实例代码
09-01
C++继承是面向对象编程中的一个核心概念，它允许创建一个新的类（子类或派生类）基于已存在的类（基类或父类）。通过继承，子类不仅可以获得基类的所有成员（包括数据成员和成员函数），还可以添加新的功能或者重写...
C++继承详解
lim6ere的博客
03-29 1295
在本篇文章中我们将会学到有关继承方面的知识，其中C++中三大特性分别为：封装，继承多态。由此可见继承在学习中的重要性，接下来我们来一起看一下有关继承方面的知识吧！！！！😘 😚😘 😚😘 😚以上就是今天要讲的内容，本文仅仅详细介绍了C++继承的相关知识。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
C++ 继承
Mike的博客
08-11 2290
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法(成员函数)和属性(成员变量)，这样产生新的类，称子类。需要注意的是子类的operator=隐藏了父类的operator=，所以显示调用父类的operator=，需要指定父类作用域。(1).public继承的子类对象 可以赋值给 父类的对象 / 父类的指针 / 父类的引用。，多继承对象在内存中的模型是，先继承的父类在前面，后面继承的父类在后面，子类成员在放到最后面。
c++中 static 变量和函数能否被子类继承
转载和创作优秀的博客
08-19 1236
c++中 static 变量和函数能否被子类继承
C++中的继承
qq_61273847的博客
08-08 1105
c++里继承详解
当C++的static遇上了继承
hanzhaoqiao1436的博客
06-07 393
这是因为我们是定义A了来指向new出来的B, 那么 b1->GetCount()的时候其实是调用了类A的GetCount()。毫不意外，因为B构造的时候就会调用A的构造函数，所以，A的Count_为8，B的Count_为5.3、怎么样来获取实例化的B的数量呢？其实再增加一个virtual就好了。比如我们想要统计下当前类被实例化了多少次，我们通常会这么写。1、现在做下小修改，让B继承自A，结果会发生变化吗？2、再次修改，用new的方式创建。输出理所当然的是 3 和 5。结果又成了熟悉的8、 5。
C++: 静态成员和子继承
sctq8888的专栏
01-10 874
Meyers在条款7中给出了一个用于实现 "class   专属的new-handlers "，用class   X实现了一个  用template和inheritance实现了一个，在template版本中，Meyers解释说：  之所以使用inheritance是为了使derived   class   也具有这种能力（class   专属的new-handlers）。  而之所以使用t
C++-------继承中静态成员的处理
Allen_Xu17
12-28 1139
#include &lt;iostream&gt; using namespace std; //继承中静态成员的处理； //类似非静态成员的处理； class Base { public: static void func() { cout &lt;&lt; "调用func()" &lt;&lt; endl; } static void func(int a) { co...
C++ 类中静态成员和静态成员函数的继承覆盖
weixin_44477424的博客
10-07 8846
C++中子类是否可以继承父类的静态成员和静态成员函数？
C++学习笔记 —— static
Charles Ren's Tech Blog
02-20 326
文章目录继承的方式继承中构造和析构顺序当父类中没有无参构造多继承虚继承 继承的方式 首先继承肯定拿不到父类中的private成员，只能拿public和protected 继承的三种方式： 公有继承，那么子类拿到的父类public和protected还放到自己的public和protected。 保护继承，子类拿到父类的都放到自己的protected。 私有继承，子类拿到父类的都放到自己的pri...
C++当中的继承（二）
lmbuhuiku的博客
09-10 1007
每一次调用基类的构造函数的时候都会对我们 的静态成员变量进行++操作，这样不论是创建我们的基类对象还是创建我们的派生类对象都会进行统计，我们这个类型的对象个数也就被统计出来了。当我们产生该种继承方式的时候就会出现数据冗余和二义性的问题，因为我们会发现在类B和类C当中都继承了类A，所以我们类A当中的数据自然也就复制了一份到我们的类B和类C当中了，那么派生类D在继承类B和类C的时候又会将类B和类C当中的数据复制一份到我们的类D当中。所谓的虚继承就是专门应对我们菱形继承所带来的问题所引入的概念。
【C++深度探索】继承机制详解（二）
Renswc的博客
07-08 3312
菱形继承是指在C++中使用多重继承时，出现了多个派生类继承同一个基类，而最终有一个类同时继承了这些派生类，形成了一个菱形的继承结构。
C++继承详解与示例
"C++继承介绍，讲解了C++中的继承概念，包括public继承以及virtual、non-virtual和pure virtual成员函数的区别。通过示例代码展示了如何使用继承，并且验证了基类指针可以调用派生类对象的方法，但反之不行。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值