10_3、C++继承与派生：派生类成员访问

2024-06-11 19:28
文章标签 c++ 访问 继承 成员 派生类 派生

本文主要是介绍10_3、C++继承与派生：派生类成员访问，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

派生类成员访问

  • 作用域分辨符
  • 虚基类
    • 概念及用法
    • 虚基类派生类的构造函数
  • 赋值兼容规则

作用域分辨符

如果派生类中存在和基类中完全相同的函数，将发生同名覆盖。如果在派生类中存在一个和基类某数据成员同名的数据成员，或者和基类某成员函数的名称和参数表都相同的成员函数，则派生类中的新成员就覆盖了基类成员，不管是在派生类内还是在派生类外部只能通过成员名访问到派生类的成员，而访问不到基类成员。
如果需要在派生类中访问基类中的同名成员怎么办呢？
可以通过基类名和作用域分辨符来访问基类中的同名成员。作用域分辨符就是“::”。

  • 在派生类内部访问基类同名成员的语法形式是：
基类名::数据成员名;           // 数据成员
基类名::函数成员名(参数表);   // 函数成员
  • 在派生类外通过派生类对象访问的话，前面还要加上“派生类对象名.”：
派生类对象名.基类名::数据成员名;                  // 数据成员
派生类对象名.基类名::函数成员名(参数表);   // 函数成员

这里的基类名就限定了后面的成员属于哪个类。

如果多个基类具有同名成员，派生类也新增了同名成员，则派生类成员会覆盖所有基类中的同名成员。通过成员名只能访问到派生类的成员，要访问各基类的同名成员就需要使用作用域分辨符。而如果派生类中不存在同名成员，访问多个基类的同名成员也需要使用作用域分辨符，因为从不同基类继承过来的同名成员具有相同的作用域，通过成员名无法唯一标识成员，所以也需要作用域分辨符来分辨。

  1. 多继承情况下同名覆盖的例子
#include <iostream>
using namespace std;
class Base1                // 基类Base1的声明
{
public:int x;void show()        { cout<<"x of Base1: "<<x<<endl; } 
};
class Base2                // 基类Base2的声明
{
public:int x;void show()        { cout<<"x of Base2: "<<x<<endl; } 
};
class Child : public Base1, public Base2    // 派生类Child的声明
{
public:int x;void show()        { cout<<"x of Child: "<<x<<endl; } 
};
int main()
{Child child;child.x = 5;          // 访问派生类数据成员child.show();         // 调用派生类函数成员child.Base1::x = 7;   // 使用作用域分辨符访问基类Base1的数据成员child.Base1::show();  // 使用作用域分辨符调用基类Base1的函数成员child.Base2::x = 8;   // 使用作用域分辨符访问基类Base2的数据成员child.Base2::show();  // 使用作用域分辨符访问基类Base2的函数成员return 0;
}

在这里插入图片描述

  • 主函数main中声明了派生类Child的对象child，因为同名覆盖，所以通过成员名只能访问派生类Child的成员，要访问基类Base1和Base2的同名成员就需要像上面那样使用作用域分辨符访问。如果在派生类Child的成员函数show中访问基类Base1的同名成员，比如x，则可以将Child的show函数修改为：void show() { cout<<"x of Child: "<<Base1::x<<endl; }。
  1. 多继承情况下无同名覆盖的例子
    将上例中派生类Child的新增同名成员去掉，改为：
class Child : public Base1, public Base2
{
};

程序其余部分不变，则主函数main中的语句child.x = 5;和child.show();就会编译报错，因为这两个标识符具有二义性，系统无法唯一标识它们，不知道该访问哪个成员。只能通过作用域分辨符来访问。

  1. 如果派生类的全部或者部分基类有共同的基类，也就是说派生类的这些基类是从同一个基类派生出的，那么派生类的这些直接基类从上一级基类继承的成员都具有相同的名称，即都是同名成员，要访问它们就必须通过直接基类限定，使用作用域分辨符访问。
#include <iostream>
using namespace std;
class Base0                    // 基类Base0的声明
{
public:int x;void show()      { cout<<"x of Base0: "<<x<<endl; }
};
class Base1 : public Base0     // 由Base0派生的类Base1的声明
{
};
class Base2 : public Base0     // 由Base0派生的类Base2的声明
{
};
class Child : public Base1, public Base2
{
};
int main()
{Child child;child.Base1::x = 3;      // 通过直接基类Base1限定成员child.Base1::show();child.Base2::x = 5;      // 通过直接基类Base2限定成员child.Base2::show();return 0;
}

在这里插入图片描述
我们先声明一个基类Base0，Base0中有数据成员x和函数成员show，再声明类Base1和Base2，它们都由Base0公有继承而来，最后从Base1和Base2共同派生出类Child。这时Base0的成员经过到Base1和Base2再到Child的两次派生过程，出现在Child类中时，实际上Base0的数据成员x已经是两个不同的成员，只是名称相同但是在内存中是两份，函数成员show也是两个不同的成员，只是名称相同但是函数体可能不同。这就需要使用作用域分辨符访问了，但是不能用基类Base0来限定，因为这样还是不能说明成员是从Base1还是Base2继承而来，所以必须使用直接基类Base1或者Base2来限定，达到唯一标识成员的目的。
上面的主函数main中定义了派生类Child的对象child，如果只通过成员名访问成员x和show，系统就不能确定访问哪个x和哪个show，这就需要使用直接基类Base1或者Base2和作用域分辨符来访问它们。
数据成员x在内存中有两份拷贝，可以存放不同的数值，但是一般我们只需要一个这样的拷贝，那多出来的那个就是对内存的浪费。解决这个问题就需要后面讲的虚基类技术。

虚基类

概念及用法

  • 场景：如果派生类的全部或者部分基类有共同的基类，那么派生类的这些直接基类从上一级基类继承的成员都具有相同的名称，定义了派生类的对象后，同名数据成员就会在内存中有多份拷贝，同名函数也会有多个映射。
  • 解决方案：访问这些同名成员时，为了唯一标识它们可以使用作用域分辨符，也可以使用虚基类技术。

虚基类：将派生类直接基类的共同基类声明为虚基类后，派生类从不同的直接基类继承来的同名数据成员在内存中就会只有一份拷贝，同名函数也会只有一个映射，这样不仅实现了唯一标识同名成员，而且也节省了内存空间。（赋值时只能赋一个值，若不用虚基类则占用多个内存，可以赋多个值）
虚基类声明的语法形式为：

class 派生类名:virtual 继承方式 基类名
  • 这里关键字virtual跟继承方式一样，只限定紧跟在它后面的基类。比如，声明了类A为虚基类，类B为A的派生类，类C也是A的派生类，类D是由类B和C共同继承而来，则类B和类C从A继承的同名数据成员在类D的对象中只有一份拷贝，同名函数成员也只有一个函数体。(声明了那个基类是虚基类，那么和其有关的派生类对象调用该基类中的数据成员和函数成员时只会在内存中拷贝一份，不管有多少重继承关系和什么继承途径)
#include <iostream>
using namespace std;
class Base0                    // 基类Base0的声明
{
public:int x;void show()      { cout<<"x of Base0: "<<x<<endl; }
};
class Base1 : virtual public Base0     // Base0为虚基类，公有派生Base1类
{
};
class Base2 : virtual public Base0     // Base0为虚基类，公有派生Base2类
{
};
class Child : public Base1, public Base2
{
};
int main()
{Child child;child.x = 5;child.show();return 0;
}

在这里插入图片描述
声明虚基类只需要在它的派生类声明时使用关键字virtual修饰。

我们对作用域分辨符和虚基类技术进行对比分析可知，使用作用域分辨符唯一标识同名成员时，派生类中有同名成员的多个拷贝，可以存放不同的数据，进行不同的操作，而使用虚基类时派生类的同名成员只有一份拷贝，更节省内存。我们在软件开发中可以根据实际情况自己做出选择。

虚基类派生类的构造函数

如果虚基类定义了带参数表的非默认构造函数，没有定义默认形式的构造函数，那么情况会有些复杂。因为由虚基类直接或间接继承的所有派生类，都必须在构造函数的成员初始化列表中给出对虚基类成员的初始化。

#include <iostream>
using namespace std;
class Base0                    // 基类Base0的声明
{
public:Base0(int y)     { x=y; }int x;void show()      { cout<<"x of Base0: "<<x<<endl; }
};
class Base1 : virtual public Base0     // Base0为虚基类，公有派生Base1类
{
public:Base1(int y):Base0(y)    { }
};
class Base2 : virtual public Base0     // Base0为虚基类，公有派生Base2类
{
public:Base2(int y):Base0(y)    { }  
};
class Child : public Base1, public Base2
{
public:Child(int y):Base0(y),Base1(y),Base2(y)   { }
};
int main()
{Child child(3);child.show();return 0;
}

在这里插入图片描述

  • 如果不是虚基类，那么Base0这个基类的构造函数将被调用3次，这里采用虚基类，编译器在遇到这种情况时会进行特殊处理：如果构造的对象中有从虚基类继承来的成员，那么虚基类成员的初始化由而且只由最远派生类的构造函数调用虚基类的构造函数来完成。
  • 最远派生类就是声明对象时指定的类，上面例子中构造对象child时，类Child就是最远派生类。除了最远派生类，它的其他基类对虚基类构造函数的调用会被忽略。上例中就只会由Child类的构造函数调用虚基类Base0的构造函数完成成员x的初始化，而Child类的基类Base1和Base2对虚基类Base0构造函数的调用会被忽略。

赋值兼容规则

派生类如果是从基类公有继承的，则它会包含基类中除构造函数和析构函数外的所有成员，基类的公有成员也成为派生类的公有成员，又因为对象只能访问类的公有成员，所以基类对象具有的功能，派生类对象都有。这样就引出了赋值兼容规则
***赋值兼容规则就是指在基类对象可以使用的地方都可以用公有派生类对象来代替。***注意必须是公有派生类。
赋值兼容规则中的代替有三种方式：

  1. 派生类的对象可以赋值给基类的对象。
  2. 派生类对象的地址可以赋值给基类类型的指针。
  3. 派生类对象可以用来初始化基类的引用。
class Base
{...
};
class Child : public Base
{...
};
Base base, *pBase;
Child child;base = child;     //赋值
pBase = &child；  //指针
Base &b = child;  //引用

作用：
因为有了赋值兼容规则，有了上述三种赋值方式，所以函数的参数中有基类对象或者基类指针又或者基类引用时，我们可以直接传入派生类对象或者派生类对象的地址作为实参来执行相同的操作。这样的好处是什么呢？那就是我们想对基类及派生类的对象做相同的操作时，只要定义一个函数就行了，它的参数为基类对象或者基类指针也或者是基类引用。这样就大大提高了软件开发的效率。
公有派生类对象可以代替基类对象使用，但是我们只能使用它从基类继承的成员，而无法使用它的新添成员。

#include <iostream>
using namespace std;
class Base           // 基类Base的声明
{
public:void show()    { cout << "Base::show()" << endl; }      // 公有成员函数show
};
class Child0 : public Base     // 类Base的公有派生类Child0的声明
{
public:void show()    { cout << "Child0::show()" << endl; }    // 公有成员函数show
};
class Child1 : public Child0   // 类Child0的公有派生类Child1的声明
{
public:void show()    { cout << "Child1::show()" << endl; }    // 公有成员函数show
};
void CallShow(Base *pBase)     // 一般函数，参数为基类指针
{pBase->show();
}
int main()
{Base base;                 // 声明Base类的对象Base *pBase;             // 声明Base类的指针Child0 ch0;                 // 声明Child0类的对象Child1 ch1;                 // 声明Child1类的对象pBase = &base;        // 将Base类对象base的地址赋值给Base类指针pBaseCallShow(pBase);pBase = &ch0;            // 将Child0类对象ch0的地址赋值给Base类指针pBaseCallShow(pBase);pBase = &ch1;            // 将Child1类对象ch1的地址赋值给Base类指针pBaseCallShow(pBase);return 0;
}

在这里插入图片描述

  • 针对基类中函数的操作，可以直接从公有派生类的对象进行赋值来操作。不用再对派生类单独创建操作函数
  • 我们首先定义了一个函数CallShow，其参数pBase为基类Base类型的指针，根据赋值兼容规则，我们可以用公有派生类对象的地址为基类指针赋值，那么CallShow函数就可以处理这个类族的所有对象。在主函数中我们就分别把基类对象base的地址、派生类对象ch0的地址和派生类对象ch1的地址赋值给基类指针pBase，然后将pBase作为实参调用CallShow，在CallShow中调用了成员函数show。
  • 将派生类对象的地址赋值给pBase以后，通过pBase只能访问派生类从基类继承的成员。所以即使指针pBase指向的是派生类对象ch0或者ch1，在CallShow中通过pBase也只能调用从基类Base继承的成员函数show，而不会调用Child0类或者Child1类的成员函数show。因此主函数中三次调用CallShow函数，都是访问的基类Base的成员函数show，输出都是Base::show()。

即使派生类对象代替了基类对象，它也只能产生基类的功能，自己的新功能无法体现。要想在代替以后同样能够实现自己的功能，就要用到面向对象设计的另一个特性–多态性。

这篇关于10_3、C++继承与派生：派生类成员访问的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1052070。

相关文章

深入理解C++ 空类大小

深入理解C++ 空类大小

《深入理解C++空类大小》本文主要介绍了C++空类大小,规定空类大小为1字节,主要是为了保证对象的唯一性和可区分性,满足数组元素地址连续的要求,下面就来了解一下... 目录1. 保证对象的唯一性和可区分性2. 满足数组元素地址连续的要求3. 与C++的对象模型和内存管理机制相适配查看类对象内存在C++中，规
阅读更多...
关于Java内存访问重排序的研究

关于Java内存访问重排序的研究

《关于Java内存访问重排序的研究》文章主要介绍了重排序现象及其在多线程编程中的影响,包括内存可见性问题和Java内存模型中对重排序的规则... 目录什么是重排序重排序图解重排序实验as-if-serial语义内存访问重排序与内存可见性内存访问重排序与Java内存模型重排序示意表内存屏障内存屏障示意表Int
阅读更多...
SpringBoot实现基于URL和IP的访问频率限制

SpringBoot实现基于URL和IP的访问频率限制

《SpringBoot实现基于URL和IP的访问频率限制》在现代Web应用中,接口被恶意刷新或暴力请求是一种常见的攻击手段,为了保护系统资源,需要对接口的访问频率进行限制,下面我们就来看看如何使用... 目录1. 引言2. 项目依赖3. 配置 Redis4. 创建拦截器5. 注册拦截器6. 创建控制器8.
阅读更多...
SpringBoot如何访问jsp页面

SpringBoot如何访问jsp页面

《SpringBoot如何访问jsp页面》本文介绍了如何在SpringBoot项目中进行Web开发,包括创建项目、配置文件、添加依赖、控制层修改、测试效果以及在IDEA中进行配置的详细步骤... 目录SpringBoot如何访问JSP页python面简介实现步骤1. 首先创建的项目一定要是web项目2. 在
阅读更多...
在 VSCode 中配置 C++ 开发环境的详细教程

在 VSCode 中配置 C++ 开发环境的详细教程

《在VSCode中配置C++开发环境的详细教程》本文详细介绍了如何在VisualStudioCode（VSCode）中配置C++开发环境,包括安装必要的工具、配置编译器、设置调试环境等步骤,通... 目录如何在 VSCode 中配置 C++ 开发环境：详细教程1. 什么是 VSCode？2. 安装 VSCo
阅读更多...
Linux限制ip访问的解决方案

Linux限制ip访问的解决方案

《Linux限制ip访问的解决方案》为了修复安全扫描中发现的漏洞,我们需要对某些服务设置访问限制,具体来说,就是要确保只有指定的内部IP地址能够访问这些服务,所以本文给大家介绍了Linux限制ip访问... 目录背景：解决方案：使用Firewalld防火墙规则验证方法深度了解防火墙逻辑应用场景与扩展背景：
阅读更多...
Python使用pysmb库访问Windows共享文件夹的详细教程

Python使用pysmb库访问Windows共享文件夹的详细教程

《Python使用pysmb库访问Windows共享文件夹的详细教程》本教程旨在帮助您使用pysmb库,通过SMB（ServerMessageBlock）协议,轻松连接到Windows共享文件夹,并列... 目录前置条件步骤一：导入必要的模块步骤二：配置连接参数步骤三：实例化SMB连接对象并尝试连接步骤四：
阅读更多...
C++11的函数包装器std::function使用示例

C++11的函数包装器std::function使用示例

《C++11的函数包装器std::function使用示例》C++11引入的std::function是最常用的函数包装器,它可以存储任何可调用对象并提供统一的调用接口,以下是关于函数包装器的详细讲解... 目录一、std::function 的基本用法1. 基本语法二、如何使用 std::function
阅读更多...
【C++ Primer Plus习题】13.4

【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++包装器

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

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2