C++(十五)继承 part1

2024-09-06 05:36
文章标签 c++ 继承 十五 part1

本文主要是介绍C++(十五)继承 part1,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

一、继承的概念

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


        下面我们看到没有继承之前我们设计了两个类Student和Teacher,Student和Teacher都有姓名/地址电话/年龄等成员变量,都有identity身份认证的成员函数,设计到两个类里面就是冗余的。

        他们一些不同的成员变量和函数,比如老师独有成员变量是职称,学生的独有成员变量是学号;学生的独有成员函数是学习,老师的独有成员函数是授课。

为了解决此类代码冗余的问题,C++引入了继承

二、继承的定义格式

基类(Base Class):这是一个现有的类,它的属性(成员变量)和方法(成员函数)可以被其他类继承。

派生类(Derived Class):这是一个从基类继承而来的类。

下面我们看到Person是父类也称作基类。Student是子类,也称作派生类。(因为翻译的原因,所以既叫父类/子类,也叫基类/派生类)

继承定义特点概述:

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

示例:


#include <iostream>
#include <string>
using namespace std;// 基类:Person
class Person {
protected:string name;string address;string phoneNumber;public:Person(const string& name, const string& address, const string& phoneNumber): name(name), address(address), phoneNumber(phoneNumber) {}// 基类成员函数void identity() const {//... ...}
};// 派生类:Student
class Student : public Person     //此处注意继承的写法
{
private:string studentNumber;public:Student(const string& name, const string& address, const string& phoneNumber, const string& studentID): Person(name, address, phoneNumber), studentNumber(studentID) {}// 派生类独有成员函数void study() const {cout << name << " is studying." << endl;}
};// 派生类:Teacher
class Teacher : public Person     //此处注意继承的写法
{
private:string title; //职称public:Teacher(const string& name, const string& address, const string& phoneNumber, const string& title): Person(name, address, phoneNumber), title(title) {}// 派生类独有成员函数void teach() const {cout << name << " is teaching." << endl;}
};

可以把上面代码改成现在这样:

创建一个基类 Person 来避免冗余,然后让 StudentTeacher 继承这个基类。基类 Person 包含共有的成员变量和函数,而 StudentTeacher 则包含各自特有的成员变量和函数。 

这里我们将学习第三种访问限定符

  1. public 公有
  2. protected 保护 (结合继承规则介绍)
  3. private 私有

继承规则如下: 

接下来的分析将围绕这张表,逐步学习继承的规则。

先看什么叫继承方式,和3种不同的基类成员呢?

基类成员

表中的类成员指的就是在基类(父类)中的方法和属性,根据访问限定符,来规定上下文中的可见性和可访问性,和以往学习的一样,只是多了protected(保护)的使用。

依然用我们上面的代码来举例说明(为观察效果作出了小改动):

继承方式

  • 什么叫继承方式呢?

        继承方式(Inheritance Type)指的是在 C++ 中派生类(子类)继承基类(父类)时指定的访问级别。这种访问级别会影响基类成员在派生类中的可见性和访问权限。

继续使用刚刚的代码来说明:

 刚刚我们使用的就是公有继承(public)

对应的当然有保护继承私有继承

继承规则

知道各种基类成员和继承方式的基本概念之后,我们就可以学习具体的代码怎么写呢?

其实非常简单,大家先看完3个示例,结合下图,就能一一理解清楚了。

示例1:

公有继承使用:

  • 基类的 public 成员在派生类中仍然是 public 的。
  • 基类的 protected 成员在派生类中仍然是 protected 的。
  • 基类的 private 成员仍然无法在派生类中访问
//基类
class Base {
public:int publicMember;
protected:int protectedMember;
private:int privateMember;
};//派生类
class Derived : public Base {
public:void accessBaseMembers() {publicMember = 10;    // 可以访问protectedMember = 20; // 可以访问// privateMember = 30; // 无法访问,编译错误}
};

公有继承是最常用的继承方式,因为它保持了基类成员的访问控制,同时允许派生类公开访问基类的公有接口。 

示例2: 

保护继承使用:

  • 基类的 public 成员在派生类中变成 protected 的。
  • 基类的 protected 成员在派生类中仍然是 protected 的。
  • 基类的 private 成员仍然无法在派生类中访问。
//基类
class Base {
public:int publicMember;
protected:int protectedMember;
private:int privateMember;
};
//派生类
class Derived : protected Base {
public:void accessBaseMembers() {publicMember = 10;    // 可以访问protectedMember = 20; // 可以访问// privateMember = 30; // 无法访问,编译错误}
};
int main() {Derived d;// d.publicMember = 10;     // 无法访问,编译错误
}

保护继承限制了派生类中对基类成员的访问范围,使得基类的公有成员在派生类中不再是公有的,而是只能在派生类内部和进一步派生的子类中访问。 

  • 访问限定符protected :在类外面不能访问 ——代码种main函数无法访问protected 的成员 

 通过画图让大家更具体的理解继承里面发生了什么:

【注意】继承做了这些事情,但是实际代码并不能这样写,只是为了形象直观地给大家呈现效果

示例3:

私有继承的使用 

  • 基类的 publicprotected 成员在派生类中都变成 private 的。
  • 基类的 private 成员仍然无法在派生类中访问。
class Base {
public:int publicMember;
protected:int protectedMember;
private:int privateMember;
};class Derived : protected Base {
public:void accessBaseMembers() {publicMember = 10;    // 可以访问protectedMember = 20; // 可以访问// privateMember = 30; // 无法访问,编译错误}
};int main() {Derived d;// d.publicMember = 10; // 无法访问,编译错误
}

图示: 

通过3个例子很直观的观察到继承方式的不同会如何作用于派生类了。

最后注意一在基类中的private成员

  • 不可访问性:基类的 private 成员(包括数据成员和成员函数)在派生类中是不可访问的。派生类不能直接访问或修改基类的 private 成员,即使是通过派生类的成员函数。

  • 继承但不可访问:虽然 private 成员被继承到了派生类中,但它们只能通过基类自己的成员函数访问。派生类无法直接访问这些成员,但可以通过基类的 publicprotected 成员函数间接访问。

  • 控制实现细节:使用 private 访问权限的一个主要目的是隐藏类的实现细节。这样,派生类和外部代码都无法依赖或修改这些私有细节,这增强了类的封装性和安全性。

  • 不可重写性:基类的 private 成员函数不能在派生类中被重写。因为它们在派生类中是不可见的,因此派生类无法定义与基类中 private 成员函数同名的函数。

示例: 

#include <iostream>
#include <string>
using namespace std;
class Base {
private:int privateData;void privateFun() {// 基类的私有成员函数}public:Base() : privateData(0) {}int getPrivateData() const {return privateData; // 基类的公共函数可以访问私有成员}
};class Derived : public Base {
public:void Derived_Fun() {// privateData = 10; // 错误:无法访问基类的私有成员// privateFun(); // 错误:无法调用基类的私有成员函数}
};
int main()
{Derived der;der.getPrivateData(); //合法return 0;
}

private总结:private成员无论何种继承方式在子类中都是不可见的。

使用总结:

 三、父类与子类间赋值

        在C++中,父类与子类之间的赋值涉及一些规则和注意事项,特别是在对象赋值、对象间的指针或引用赋值,以及赋值运算符重载的情况下。子类对象可以赋值给父类对象,但父类对象赋值给子类对象则需要满足特定条件,否则会出现问题。

赋值规则:

  • 子类对象 可以赋值给父类对象 (对象切割下面会详细介绍
  • 子类对象 可以赋值给父类指针或引用(父类指针可以指向子类对象)
  • 父类对象 不能赋值给子类对象

下面结合代码、图形来解释理解一下这部分内容 

3.1 子类对象赋值给父类对象 

        继续沿用上面示例,main函数中我们实例化出 Student 对象,并试图将其赋值给一个 Person 对象。由于 Person 类并不包含 Student 类独有的 studentNumber 成员变量,赋值时将会发生对象切割。 

#include <iostream>
#include <string>
using namespace std;// 基类:Person
class Person {
protected:string name;string address;string phoneNumber;public:Person(const string& name, const string& address, const string& phoneNumber): name(name), address(address), phoneNumber(phoneNumber) {}// 基类成员函数void identity() const {//... ...}
};
// 派生类:Teacher(没用到所以省略了)
// 派生类:Student
class Student : public Person {
private:string studentNumber;public:Student(const string& name, const string& address, const string& phoneNumber, const string& studentNumber): Person(name, address, phoneNumber), studentNumber(studentNumber) {}// 派生类独有成员函数void study() const {cout << name << " is studying." << endl;}
};int main() {//              姓名     地址         电话号码      学号Student student("张三", "上海 xx街", "1356729950", "2024090530");Person person = student;  // 对象切割person.identity();  // 调用的是 Person 类的 identity() 函数// person.study();   // 错误:Person 类没有 study() 函数
}

对象切割(Object Slicing)

        也称作“切片”,对象切割发生在将一个派生类对象赋值给一个基类对象时。在这个过程中,派生类中的特有成员和行为会被“切割”掉,只保留基类部分。这是因为基类对象无法容纳派生类对象的全部信息。

结合图形在上面main函数中发生的具体过程: 

        在这个例子中,person 对象将只包含 nameaddressphoneNumber 成员,而 studentNumberstudy() 函数无法访问。也就是说,person 对象只是 student 对象的 Person 部分。先简单理解成这样,但是成员函数C++中做了特殊处理下面会重点讲解。

希望大家结合图形可以很好的理解对象切割这一概念。 

3.2 指针和引用赋值 

        如果我们使用指针或引用,将 Student 对象赋值给 Person 指针或引用,可以避免对象切割,并且允许通过虚函数表调用子类的方法(假设使用了虚函数:多态内容下一章细讲)。不过在当前类设计中,我们没有使用虚函数,但我们仍然可以通过指针或引用调用基类的成员函数。

// 基类:Person
class Person {
protected:string name;string address;string phoneNumber;public:Person(const string& name, const string& address, const string& phoneNumber): name(name), address(address), phoneNumber(phoneNumber) {}// 基类成员函数void identity() const {cout << name << endl;cout << address << endl;cout << phoneNumber << endl;}
};
// 派生类:Teacher(没用到所以省略了)
// 派生类:Student
class Student : public Person {
private:string studentNumber;public:Student(const string& name, const string& address, const string& phoneNumber, const string& studentNumber): Person(name, address, phoneNumber), studentNumber(studentNumber) {}// 派生类独有成员函数void study() const {cout << name << " is studying." << endl;}
};int main() {//              姓名     地址         电话号码      学号Student student("张三", "上海 xx街", "1356729950", "2024090530");Person person = student;        // 对象切割Person& personRef = student;    // 使用引用,避免对象切割personRef.identity();           // 调用的是 Person 类的 identity() 函数Person* personPtr = &student;   // 使用指针,避免对象切割personPtr->identity();          // 调用的是 Person 类的 identity() 函数//为了观察在identity中打印些信息
}

 运行结果:

张三
上海 xx街
1356729950
张三
上海 xx街
1356729950

集合图形理解: 

        由于 personRefpersonPtr 都指向 student 对象的 Person 部分,调用 identity() 函数时会表现出多态行为(如果该函数是虚函数),但它们无法直接访问 Student 类中的 study() 函数。因为指针和引用的用法是一样的,所以这里只使用一个作图表示。 

 3.3 父类对象赋值给子类对象

父类对象不能直接赋值给子类对象!!!

父类对象不能直接赋值给子类对象!!!

父类对象不能直接赋值给子类对象!!!

父类对象为什么不能直接赋值给子类对象呢?

父类子类我们依旧用上面示例只改main函数做说明:

错误1: 

int main() {//             姓名     地址         电话号码      Person person("狗剩", "北京 xx区", "1350000000");//              姓名     地址         电话号码      学号Student student("张三", "上海 xx街", "1356729950", "2024090530");//student = person;  // 错误:不能将父类对象赋值给子类对象//该操作编译都过不了
}

错误2:  

有小伙伴可以在想:可以通过类型转换再赋值啊?可以通过显式转换来尝试强制赋值。但这种方式非常危险,可能导致程序崩溃或不确定的行为,因为子类特有的成员变量在父类中并不存在

int main() {//             姓名     地址         电话号码      Person person("狗剩", "北京 xx区", "1350000000");Student* studentPtr = (Student*)&person;  // 不安全的转换// studentPtr->study();  // 可能导致未定义行为,因为 person 并没有 studentNumber//此做法虽然可以过编译,但非常不推荐!!!
}

 小伙伴们可以结合下面图形应该也是不难理解的:

 

四、隐藏

接下来我们将详细学习C++中继承体系中对成员函数的处理机制——隐藏

在往下学习之前我们不能忘记一点:

  • 就算是有继承关系,也不妨碍父类依然可以单独像普通类一样使用,一样可以实例化出自己的对象。

      

4.1 隐藏的概念

        隐藏(hiding),也叫重定义,子类和父类中有同名成员,子类成员将屏蔽父类对同名成员的直接访问,这意味着通过子类对象调用该函数时,默认只会调用子类的版本,而父类的同名函数将无法直接被调用。(在子类成员函数中,可以使用 基类::基类成员 显示访问)

【注意】在实际中在继承体系里面最好不要定义同名的成员。 

4.2 构成隐藏的条件

  • 成员函数的隐藏,只需要函数名相同就构成隐藏

我们先简单看看看隐藏是什么样子的:

4.3 使用


#include <iostream>
#include <string>
using namespace std;
// 基类:Person
class Person {
protected:string name;string address;string phoneNumber;public:Person(const string& name, const string& address, const string& phoneNumber): name(name), address(address), phoneNumber(phoneNumber) {}// 基类成员函数void identity() const {cout << "Person:" << endl;cout << name << endl;cout << address << endl;cout << phoneNumber << endl;}
};
// 派生类:Student
class Student : public Person {
private:string studentNumber;public:Student(const string& name, const string& address, const string& phoneNumber, const string& studentNumber): Person(name, address, phoneNumber), studentNumber(studentNumber) {}// 派生类独有成员函数void study() const {cout << name << " is studying." << endl;}//identity()成员函数名相同够成隐藏void identity() const {cout << "Student:" << endl;cout << name << endl;cout << address << endl;cout << phoneNumber << endl;cout << studentNumber << endl;}};
int main() {//              姓名     地址         电话号码      学号Student student("张三", "上海 xx街", "1356729950", "2024090530");student.identity();
}

 运行结果:

Student:
张三
上海 xx街
1356729950
2024090530

        在 Student 类中,定义了一个与基类 Person 中同名的 identity() 函数。这个新的 identity() 函数会隐藏基类中的同名函数。具体来说,当通过 Student 对象调用 identity() 函数时,将调用 Student 中的版本,而不是 Person 中的版本。这就是函数隐藏。 

 


 

当我们对隐藏有了基本的概念,现在来对继承体系成员函数处理机制 做进一步探讨

  •  继承体系中基类和派生类都有独立的作用域。 

 

在示例代码中:

int main() {//              姓名     地址         电话号码      学号Student student("张三", "上海 xx街", "1356729950", "2024090530");student.identity();
}

 Student类的对象调用identity(),派生类的作用域中查找某个名称时,优先查找派生类自己定义的成员

基类和派生类的作用域是独立的,即基类中的名称查找不会受到派生类中同名成员的影响。


关于隐藏我们再看最后一个问题:下面这段代码调用的是父类还是子类的 identity() 呢?

// 基类:Person
#include <iostream>
#include <string>
using namespace std;
class Person {
protected:string name;string address;string phoneNumber;public:Person(const string& name, const string& address, const string& phoneNumber): name(name), address(address), phoneNumber(phoneNumber) {}// 基类成员函数void identity() const {cout << "Person:" << endl;cout << name << endl;cout << address << endl;cout << phoneNumber << endl;}
};
// 派生类:Student
class Student : public Person {
private:string studentNumber;public:Student(const string& name, const string& address, const string& phoneNumber, const string& studentNumber): Person(name, address, phoneNumber), studentNumber(studentNumber) {}// 派生类独有成员函数void study() const {cout << name << " is studying." << endl;}//identity成员函数名相同够成隐藏void identity() const {cout << "Student:" << endl;cout << name << endl;cout << address << endl;cout << phoneNumber << endl;cout << studentNumber << endl;}};
int main() {//              姓名     地址         电话号码      学号Student student("张三", "上海 xx街", "1356729950", "2024090530");Person& personRef = student;  personRef.identity();          Person* personPtr = &student;   personPtr->identity();          
}

运行结果:

Person:
张三
上海 xx街
1356729950
Person:
张三
上海 xx街
1356729950

是的运行的都是Person中的identity(),详解:

4.3.1储存

编译器为每个类的成员函数生成一份代码,通常存储在程序的代码段(也称为文本段)中。父类和子类的 identity() 函数各自有独立的实现,分别存储在不同的位置

  • 父类 Person::identity() 函数:编译器会为 Person 类的 identity() 函数生成一份代码,并将其存储在代码段中。
  • 子类 Student::identity() 函数:同样,编译器也会为 Student 类的 identity() 函数生成一份代码,并将其存储在代码段中。

在程序的运行过程中,这两个函数的代码是独立存在的,并且不会因为它们的同名而发生冲突

4.3.2. 函数隐藏的调用机制

在编译时,编译器已经确定了调用哪个函数,这个决定依赖于调用者的静态类型,即声明时的类型——Person

  • 父类指针/引用调用: 如果你通过父类 Person 的指针或引用调用 identity() 函数,例如 personPtr->identity();personRef.identity();,编译器会在编译时将调用绑定到 Person::identity() 的实现。

  • 子类对象/指针/引用调用: 如果你通过子类 Student 的对象或引用调用 identity() 函数,例如 student.identity();,编译器会将调用绑定到 Student::identity() 的实现。

 

这篇关于C++(十五)继承 part1的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1141148

相关文章

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<

C++包装器

包装器 在 C++ 中,“包装器”通常指的是一种设计模式或编程技巧,用于封装其他代码或对象,使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍,可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型: 1. 函数包装器 函数包装器用于封装一个或多个函数,使其接口更统一或更便于调用。例如,std::function 是一个通用的函数包装器,它可以存储任意可调用对象(函数、函数

C++11第三弹:lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页: 南桥几晴秋 🌈C++专栏: 南桥谈C++ 🌈C语言专栏: C语言学习系列 🌈Linux学习专栏: 南桥谈Linux 🌈数据结构学习专栏: 数据结构杂谈 🌈数据库学习专栏: 南桥谈MySQL 🌈Qt学习专栏: 南桥谈Qt 🌈菜鸡代码练习: 练习随想记录 🌈git学习: 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�

【C++】_list常用方法解析及模拟实现

相信自己的力量,只要对自己始终保持信心,尽自己最大努力去完成任何事,就算事情最终结果是失败了,努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一:什么是list? •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二:list常用接口 •🌰1.默认成员函数 🔥构造函数(⭐) 🔥析构函数 •🌰2.list对象

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获:包含零个或者多个捕获符的逗号分隔列表 模板形参:用于泛型lambda提供个模板形参的名

6.1.数据结构-c/c++堆详解下篇(堆排序,TopK问题)

上篇:6.1.数据结构-c/c++模拟实现堆上篇(向下,上调整算法,建堆,增删数据)-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小): 2.2 C语言代码(手写堆) 2.3 C++代码(使用优先级队列 priority_queue)

【C++高阶】C++类型转换全攻略:深入理解并高效应用

📝个人主页🌹:Eternity._ ⏩收录专栏⏪:C++ “ 登神长阶 ” 🤡往期回顾🤡:C++ 智能指针 🌹🌹期待您的关注 🌹🌹 ❀C++的类型转换 📒1. C语言中的类型转换📚2. C++强制类型转换⛰️static_cast🌞reinterpret_cast⭐const_cast🍁dynamic_cast 📜3. C++强制类型转换的原因📝

C++——stack、queue的实现及deque的介绍

目录 1.stack与queue的实现 1.1stack的实现  1.2 queue的实现 2.重温vector、list、stack、queue的介绍 2.1 STL标准库中stack和queue的底层结构  3.deque的简单介绍 3.1为什么选择deque作为stack和queue的底层默认容器  3.2 STL中对stack与queue的模拟实现 ①stack模拟实现

c++的初始化列表与const成员

初始化列表与const成员 const成员 使用const修饰的类、结构、联合的成员变量,在类对象创建完成前一定要初始化。 不能在构造函数中初始化const成员,因为执行构造函数时,类对象已经创建完成,只有类对象创建完成才能调用成员函数,构造函数虽然特殊但也是成员函数。 在定义const成员时进行初始化,该语法只有在C11语法标准下才支持。 初始化列表 在构造函数小括号后面,主要用于给

2024/9/8 c++ smart

1.通过自己编写的class来实现unique_ptr指针的功能 #include <iostream> using namespace std; template<class T> class unique_ptr { public:         //无参构造函数         unique_ptr();         //有参构造函数         unique_ptr(