【c++随笔12】继承

郑同学的笔记2023-11-13 8:08

【c++随笔12】继承

原创作者：郑同学的笔记

原创地址：https://zhengjunxue.blog.csdn.net/article/details/131795289

qq技术交流群：921273910

C++ 是基于面向对象的程序，面向对象有三大特性 ------ 封装、继承、多态。

一、继承

1、继承的概念

  • 继承（inheritance）机制是面向对象程序设计，使代码可以复用的最重要的手段。
  • 它允许程序员在保持原有类特性的基础上进行扩展，以增加功能。这样产生新的类，称为派生类。
  • 继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。
  • 以前我们接触的复用都是函数复用，而继承是类设计层次的复用。
cpp 复制代码 
#include <iostream>
#include<string>
using namespace std;
class Person {
    /* 共有的信息 */
public:
    void print()
    {
        cout << "name = "<<m_name << "\nage = "<<m_age << endl;
    }
    string m_name;
    int m_age;
};

/* Student 公有继承了 Person */
class Student : public Person {
    string m_stuID;  // 学号
};

/* Teacher 公有继承了 Person */
class Teacher : public Person {
    string m_employeeID;  // 工号
};

int main() 
{
    Person p;
    p.print();

    Student su;
    su.print();

    Teacher t;
    t.print();

    return 0;
}

输出

  • 继承的定义格式
    Student 是 子类，我们也称之为派生类。Person 是父类，我们也称之为 基类。
cpp 复制代码 
class 派生类名:［继承方式］ 基类名{
    派生类新增加的成员
};

2、3种继承方式

  • 访问限定符：public / protected / private

下表汇总了不同继承方式对不同属性的成员的影响结果

继承方式/基类成员 public成员 protected成员 private成员
public继承 public protected 不可见
protected继承 protected protected 不可见
private继承 private private 不可见

由于 private 和 protected 继承方式会改变基类成员在派生类中的访问权限，导致继承关系复杂，所以实际开发中我们一般使用 public。

3、父类和子类对象赋值转换

  • 子类对象可以赋值给父类的对象、父类的指针、父类的引用：
cpp 复制代码 
#include <iostream>
#include<string>
using namespace std;
class Person {
    /* 共有的信息 */
public:
    void print()
    {
        cout << "name = "<<m_name << "\nage = "<<m_age << endl;
    }
    string m_name;
    int m_age;
};

/* Student 公有继承了 Person */
class Student : public Person {
    string m_stuID;  // 学号
};

int main() 
{

    Student s;
   
    Person p = s;

    Person* pointer_p = &s;

    Person& ref_p = s;

    p.print();
    pointer_p->print();
    ref_p.print();

    return 0;
}

输出

注意事项：

  • ① 父类对象不能赋值给子类对象
cpp 复制代码 
Student s;  // 子类
Person p;   // 父类
 
s = p; ❌
  • ② 父类的指针可以通过强转赋值给子类的指针，但是必须是父类的指针是指向子类对象时才是安全的。

这里父类如果是多态类型，可以使用 RTTI（Run-Time Type Information，即运行时类型识别）的 dynamic_cast 来进行识别后进行安全转换。

cpp 复制代码 
#include <iostream>
#include<string>
using namespace std;
class Person {
    /* 共有的信息 */
public:
    void print()
    {
        cout << "name = "<<m_name << "\nage = "<<m_age << endl;
    }
    string m_name;
    int m_age;
};

/* Student 公有继承了 Person */
class Student : public Person {
public:
    string m_stuID;  // 学号
};

int main() 
{

    Student s;
    // 父类的指针可以通过强制类型转换赋值给子类的指针
    Person* pointer_p = &s;
    Student* pointer_s = (Student*)pointer_p;
    pointer_s->m_stuID;

    Person p;
    // 这种情况虽然可以，但是会存在越界访问问题
    Person* pointer_p2 = &p;
    Student* pointer_s2 = (Student*)pointer_p2;
    pointer_s->m_stuID;

    return 0;
}

4、继承中的作用域------隐藏

  • 继承体系中的父类和子类都有独立的作用域，如果子类和父类有同名成员，
  • 此时子类成员会屏蔽父类对同名成员的直接访问，这种情况叫做 "隐藏" （有文章把它叫重定义，其实我不建议这种叫法，因为重定义指的是同一个作用域重复定义）。

在子类成员函数中，可以使用如下方式进行显式访问：

基类::基类成员

--

例如：在Student类中

Person::print()

cpp 复制代码 
#include <iostream>
#include<string>
using namespace std;
class Person {
    /* 共有的信息 */
public:
    void print()
    {
        cout << "name = "<<m_name << "\nage = "<<m_age << endl;
    }
    string m_name;
    int m_age;
};

/* Student 公有继承了 Person */
class Student : public Person {
public:
    void print()
    {
        cout << "name = " << m_name << "\nage = " << m_age <<"\nstuID = "<< m_stuID << endl;
    }
    string m_stuID;  // 学号
};

int main() 
{

    Student s;
    s.print();

    return 0;
}

5、继承与友元

  • 友元关系不能继承，也就是说父类友元不能访问子类私有和保护成员！
cpp 复制代码 
#include <iostream>
#include<string>
using namespace std;


class Student;
class Person {
public:
    friend void Display(const Person& p, const Student& s);
    /* 共有的信息 */

protected:
    void print()
    {
        cout << "name = "<<m_name << "\nage = "<<m_age << endl;
    }
    string m_name;
    int m_age;
};

/* Student 公有继承了 Person */
class Student : public Person {

protected:
    void print()
    {
        cout << "name = " << m_name << "\nage = " << m_age <<"\nstuID = "<< m_stuID << endl;
    }
    string m_stuID = "110";  // 学号
};

void Display(const Person& p, const Student& s)
{
    cout << p.m_name << endl;
    cout << s.m_stuID << endl;
}

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

    return 0;
}

报错

"Student::m_stuID": 无法访问 protected 成员(在"Student"类中声明)

6、继承与静态成员

  • 父类定义了 static 静态成员，则整个继承体系里面中有一个这样的成员。

可以理解为共享，父类的静态成员可以在子类共享，父类和子类都能去访问它。

无论派生出多少个子类，都只有一个 static 成员实例：

cpp 复制代码 
#include <iostream>
#include<string>
using namespace std;


class Person {
public:
    Person() {
        ++m_count;
    }
    void print()
    {
        cout << "name = "<<m_name << "\nage = "<<m_age << endl;
    }
protected:
    string m_name;
    int m_age;
public:
    static int m_count;
};

int Person::m_count = 0;
/* Student 公有继承了 Person */
class Student : public Person 
{
protected:
    string m_stuID = "110";  // 学号
};


int main() 
{
	Student s1;
	Student s2;
	Student s3;
	Person s;

	cout << "大家都可以访问" << endl;
	cout << "人数 : " << Person::m_count << endl;
	cout << "人数 : " << Student::m_count << endl;

	cout << "大家也都可以变动" << endl;
	s3.m_count = 0;
	cout << "人数 : " << Person::m_count << endl;

	cout << "并且他们的地址也都是一样的，因为所有继承体系中只有一个" << endl;
	cout << "人数 : " << &Person::m_count << endl;
	cout << "人数 : " << &Student::m_count << endl;


    return 0;
}

输出

二、继承和子类默认成员函数

1、子类构造函数

  • 子类的构造函数必须调用父类的构造函数初始化父类的那一部分成员。

如果 父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。(如下面的demo)

  • 子类对象初始化先调用父类构造再调子类构造。
cpp 复制代码 
#include <iostream>
#include<string>
using namespace std;


class Person {
public:
    Person(const char* m_name = "hello") {
        cout<<"构造 Person \n";
    }
protected:
    string m_name;
    int m_age;
};

class Student : public Person 
{
public:
	Student(const char* name, int stuID) 
		:Person(name), //如果 父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。
		m_stuID(stuID)
	{
        cout << "构造 Student \n";
	}
protected:
    int m_stuID;  // 学号
};

int main() 
{
	Student s1("",18);


    return 0;
}

思考：如何设计一个不能被继承的类？

  • 将父类的构造函数私有化：
cpp 复制代码 
class A 
{
private:
    A() {}
};

父类的构造函数私有化后，在父类的外部，父类自己也没法初始化了？

（单例模式可以这么做，如下）

cpp 复制代码 
class A {
public:
    static A CreateObject() {  // 提供一个获取对象的方式
        return A();
    }
private:
    A() {}
};
 
class B : public A {};
 
int main(void) 
{
    A a = A::CreateObject();
 
    return 0;
}

二、子类拷贝构造函数

  • 子类的拷贝构造函数必须调用父类的拷贝构造完成拷贝初始化。
cpp 复制代码 
#include <iostream>
#include<string>
using namespace std;


class Person {
public:
    Person(const char* m_name = "hello") {
        cout<<"构造 Person \n";
    }

    Person(const Person& p)
        :m_name(p.m_name)
    {
        cout << "拷贝构造 Person \n";
    }
protected:
    string m_name;
    int m_age;
};

class Student : public Person 
{
public:
	Student(const char* name, int stuID) 
		:Person(name), //如果 父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。
		m_stuID(stuID)
	{
        cout << "构造 Student \n";
	}

    Student(const Student& s)
        :Person(s), //子类的拷贝构造函数必须调用父类的拷贝构造完成拷贝初始化。
        m_stuID(s.m_stuID)
    {
        cout << "拷贝构造 Student \n";
    }
protected:
    int m_stuID;  // 学号
};


int main() 
{
	Student s1("haha",18);
    Student s2(s1);

    return 0;
}

输出

3、子类的赋值重载

  • 子类的 operator= 必须要调用父类的 operator= 完成父类的复制。
cpp 复制代码 
#include <iostream>
#include<string>
using namespace std;

class Person {
public:
    Person(const char* m_name = "hello") {
        cout<<"构造 Person \n";
    }

    Person& operator=(const Person& p)
    {
        cout << "赋值重载 Person \n";
        if(this != &p)
        {
            m_name = p.m_name;
        }
        return *this;
    }
protected:
    string m_name;
    int m_age;
};

class Student : public Person 
{
public:
    Student(const char* name, int stuID)
        :Person(name), //如果 父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。
        m_stuID(stuID)
    {
        cout << "构造 Student \n";
    }

    Student& operator=(const Student& s)
    {
        cout << "赋值重载 Student \n";
        if (this != &s)
        {
            Person::operator=(s); //子类的 operator= 必须要调用父类的 operator= 完成父类的复制。
            m_stuID = s.m_stuID;
        }
        return *this;
    }
protected:
    int m_stuID;  // 学号
};

int main() 
{
	Student s1("小白",18);
    Student s2("小黑", 18);
    s1 = s2;

    return 0;

输出

4、子类析构函数

  • 为了保证子类对象先清理子类成员再清理父类成员的顺序，先子后父。

子类析构先子后父，子类对象的析构清理是先调用子类析构再调父类析构。

  • 子类析构函数完成后会自动调用父亲的析构函数，所以不需要我们显式调用。
cpp 复制代码 
#include <iostream>
#include<string>
using namespace std;

class Person {
public:
    Person(const char* m_name = "hello") {
        cout<<"构造 Person \n";
    }

    ~Person()
    {
        cout << "析构 Person \n";
    }
protected:
    string m_name;
    int m_age;
};

class Student : public Person 
{
public:
    Student(const char* name, int stuID)
        :Person(name), //如果 父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。
        m_stuID(stuID)
    {
        cout << "构造 Student \n";
    }

    ~Student()
    {
        cout << "析构 Student \n";
    }
protected:
    int m_stuID;  // 学号
};

int main() 
{
	Student s1("小白",18);

    return 0;
}

输出

三、单继承、多继承、菱形继承

1、单继承：一个子类只有一个直接父类，我们称这种继承关系为单继承。

2、多继承：一个子类有两个或以上直接父类，我们称这种继承关系为多继承。

3、菱形继承（Diamond Inheritance）是指在类继承关系中，存在一个派生类同时继承自两个直接或间接基类，并且这两个基类又共同继承自一个共同的基类，从而形成了菱形状的继承结构。

下面是一个示例代码来说明菱形继承的概念：

cpp 复制代码 
class Animal {
public:
    void eat() {
        cout << "Animal eats." << endl;
    }
};

class Mammal : public Animal {
public:
    void run() {
        cout << "Mammal runs." << endl;
    }
};

class Bird : public Animal {
public:
    void fly() {
        cout << "Bird flies." << endl;
    }
};

class Bat : public Mammal, public Bird {
public:
    void sleep() {
        cout << "Bat sleeps." << endl;
    }
};

在上述代码中，Animal 是基类，Mammal 和 Bird 是直接派生类，而 Bat 是通过多重继承同时派生自 Mammal 和 Bird 的派生类。注意到 Mammal 和 Bird 都继承自 Animal，这就形成了菱形继承结构。

3.1、菱形继承可能引发以下问题：

  • 二义性（Ambiguity）：由于 Bat 同时继承自 Mammal 和 Bird，如果两个基类都定义了相同的成员函数或变量，编译器就无法确定该使用哪个版本，从而导致二义性错误。
  • 冗余数据：由于两个基类都继承自同一个基类 Animal，当 Bat 对象被创建时，会在内存中存在两份相同的 Animal 的数据。

3.2、为了解决菱形继承带来的问题，可以采用以下方法：

  • 使用虚拟继承（Virtual Inheritance）：在 Mammal 和 Bird 继承 Animal 时，使用 virtual 关键字表示虚拟继承，这样就可以消除冗余数据和二义性问题。
cpp 复制代码 
class Mammal : virtual public Animal {
    // ...
};

class Bird : virtual public Animal {
    // ...
};
  • 使用间接继承：在 Bat 类中只直接继承 Mammal 或 Bird 的一个，而间接继承另一个基类的成员函数或变量。
cpp 复制代码 
class Bat : public Mammal {
private:
    Bird bird;
public:
    // 使用 bird 对象来访问 Bird 类中的成员
};

菱形继承是多重继承中的一种特殊情况，需要谨慎使用，并采取适当的解决方案来避免引发问题。

4、继承和组合

  • 继承和组合 public继承是一种 is-a 的关系。也就是说每个派生类对象都是一个基类对象。
  • 组合是一种 has-a 的关系。假设B组合了A，每个B对象中都有一个A对象。
  • 优先使用对象组合，而不是类继承 。
  • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用 （white-box reuse）。术语"白箱"是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。 继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关 系很强，耦合度高。
  • 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对 象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用（black-box reuse）， 因为对象的内部细节是不可见的。对象只以"黑箱"的形式出现。 组合类之间没有很强的依赖关系， 耦合度低。优先使用对象组合有助于你保持每个类被封装。
  • 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适 合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。
cpp 复制代码 
class A {
	// ...
};
 
// 继承
class B : public A {};
 
class C {
	// ...
};
 
// 组合
class D {
	C _c;
};

继承就是团体出行，A 任何成员的修改都有可能影响 B 的实现。

组合就是自由出行，C 只要不修改公有，就不会对 D 有影响。

相关推荐
神经网络的应用5 分钟前
C++程序设计例题——第三章程序控制结构
c++·学习·算法
工业甲酰苯胺23 分钟前
聊一聊 C#线程池 的线程动态注入
java·开发语言·c#
zfenggo24 分钟前
c/c++ 无法跳转定义
c语言·开发语言·c++
图灵猿27 分钟前
【Lua之·Lua与C/C++交互·Lua CAPI访问栈操作】
c语言·c++·lua
向宇it34 分钟前
【从零开始入门unity游戏开发之——C#篇30】C#常用泛型数据结构类——list＜T＞列表、`List＜T＞` 和数组 (`T[]`) 的选择
java·开发语言·数据结构·unity·c#·游戏引擎·list
hakesashou39 分钟前
python怎么看矩阵维数
开发语言·python
daopuyun1 小时前
GB/T34944-2017 《Java语言源代码漏洞测试规范》解读——安全功能
java·开发语言·安全
A懿轩A1 小时前
C/C++ 数据结构与算法【树和二叉树】 树和二叉树，二叉树先中后序遍历详细解析【日常学习，考研必备】带图+详细代码
c语言·数据结构·c++·学习·二叉树·树
qh0526wy1 小时前
pyqt5冻结+分页表
开发语言·python·qt
hjxxlsx1 小时前
探索 C++ 自定义函数的深度与广度
开发语言·c++
热门推荐
01大模型国产化适配7-华为昇腾LLM落地可选解决方案（MindFormers、ModelLink、MindIE）02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03玄机平台应急响应—webshell查杀04电赛2024年H题智能小车基于MSPM0G3507主控MCU（利用8路灰度加上MPU6050的解决方式）具体项目报告05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06支付宝短视频平台创作分成激励项目07怎么找小红书美食探店博主合作？08【一文读懂】NTN（非地面网络）技术介绍09优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间10校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站