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++右移运算符的一个小坑及解决》文章指出右移运算符处理负数时左侧补1导致死循环,与除法行为不同,强调需注意补码机制以正确统计二进制1的个数... 目录我遇到了这么一个www.chinasem.cn函数由此可以看到也很好理解总结我遇到了这么一个函数template<typename T>unsigned
阅读更多...
C++统计函数执行时间的最佳实践

C++统计函数执行时间的最佳实践

《C++统计函数执行时间的最佳实践》在软件开发过程中,性能分析是优化程序的重要环节,了解函数的执行时间分布对于识别性能瓶颈至关重要,本文将分享一个C++函数执行时间统计工具,希望对大家有所帮助... 目录前言工具特性核心设计1. 数据结构设计2. 单例模式管理器3. RAII自动计时使用方法基本用法高级用法
阅读更多...
深入解析C++ 中std::map内存管理

深入解析C++ 中std::map内存管理

《深入解析C++中std::map内存管理》文章详解C++std::map内存管理,指出clear()仅删除元素可能不释放底层内存,建议用swap()与空map交换以彻底释放,针对指针类型需手动de... 目录1️、基本清空std::map2️、使用 swap 彻底释放内存3️、map 中存储指针类型的对象
阅读更多...
C++ STL-string类底层实现过程

C++ STL-string类底层实现过程

《C++STL-string类底层实现过程》本文实现了一个简易的string类,涵盖动态数组存储、深拷贝机制、迭代器支持、容量调整、字符串修改、运算符重载等功能,模拟标准string核心特性,重点强... 目录实现框架一、默认成员函数1.默认构造函数2.构造函数3.拷贝构造函数(重点)4.赋值运算符重载函数
阅读更多...
C++ vector越界问题的完整解决方案

C++ vector越界问题的完整解决方案

《C++vector越界问题的完整解决方案》在C++开发中,std::vector作为最常用的动态数组容器,其便捷性与性能优势使其成为处理可变长度数据的首选,然而,数组越界访问始终是威胁程序稳定性的... 目录引言一、vector越界的底层原理与危害1.1 越界访问的本质原因1.2 越界访问的实际危害二、基
阅读更多...
c++日志库log4cplus快速入门小结

c++日志库log4cplus快速入门小结

《c++日志库log4cplus快速入门小结》文章浏览阅读1.1w次，点赞9次，收藏44次。本文介绍Log4cplus，一种适用于C++的线程安全日志记录API，提供灵活的日志管理和配置控制。文章涵盖... 目录简介日志等级配置文件使用关于初始化使用示例总结参考资料简介log4j 用于Java，log4c
阅读更多...
C++归并排序代码实现示例代码

C++归并排序代码实现示例代码

《C++归并排序代码实现示例代码》归并排序将待排序数组分成两个子数组,分别对这两个子数组进行排序,然后将排序好的子数组合并,得到排序后的数组,：本文主要介绍C++归并排序代码实现的相关资料,需要的... 目录1 算法核心思想2 代码实现3 算法时间复杂度1 算法核心思想归并排序是一种高效的排序方式，需要用
阅读更多...
通过配置nginx访问服务器静态资源的过程

通过配置nginx访问服务器静态资源的过程

《通过配置nginx访问服务器静态资源的过程》文章介绍了图片存储路径设置、Nginx服务器配置及通过http://192.168.206.170:8007/a.png访问图片的方法,涵盖图片管理与服务... 目录1.图片存储路径2.nginx配置3.访问图片方式总结1.图片存储路径2.nginx配置
阅读更多...
C++11范围for初始化列表auto decltype详解

C++11范围for初始化列表auto decltype详解

《C++11范围for初始化列表autodecltype详解》C++11引入auto类型推导、decltype类型推断、统一列表初始化、范围for循环及智能指针,提升代码简洁性、类型安全与资源管理效... 目录C++11新特性1. 自动类型推导auto1.1 基本语法2. decltype3. 列表初始化3
阅读更多...
C++11右值引用与Lambda表达式的使用

C++11右值引用与Lambda表达式的使用

《C++11右值引用与Lambda表达式的使用》C++11引入右值引用,实现移动语义提升性能,支持资源转移与完美转发；同时引入Lambda表达式,简化匿名函数定义,通过捕获列表和参数列表灵活处理变量... 目录C++11新特性右值引用和移动语义左值 / 右值常见的左值和右值移动语义移动构造函数移动复制运算符
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2