（P29）继承：代码重用 ，继承 ，公有，私有，保护继承 ，默认继承保护级别 ，接口继承与实现继承 ，继承与重定义 ，继承与组合

2024-06-08 06:08
文章标签 代码 实现 接口 组合 定义 私有 默认 继承 保护 级别 公有 重用 p29

本文主要是介绍（P29）继承：代码重用 ，继承 ，公有，私有，保护继承 ，默认继承保护级别 ，接口继承与实现继承 ，继承与重定义 ，继承与组合，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

    • 1.代码重用
    • 2.继承
    • 3.公有，私有，保护继承
    • 4.默认继承保护级别
    • 5.接口继承与实现继承
    • 6.继承与重定义
    • 7.继承与组合
    • 8.私有继承的妙用
      • 注：父类的私有虚函数

1.代码重用

  • C++很重要的一个特征就是代码重用。
    在C语言中重用代码的方式就是拷贝代码、修改代码。
    C++可以用继承或者组合的方式来重用。 通过组合或继承现有的类来创建新类，而不是重新创建它们。
  • 第一种重用方式：以组合的方式实现重用的eg
//组合的方式实现重用：就是将一个类作为另外一个类的对象成员
class A
{
public:void FunA(){....}
};
class B
{
public://要实现FunB的功能，将其委托给A来实现//调用对象a_中FunA()功能来实现重用，来实现自己的代码void FunB(){...a_.FuncA();...}
private://A类是B类的子对象A a_;
};
  • 第二种重用方式就是继承

2.继承

  • 继承是使用已经编写好的类来创建新类，新的类具有原有类的所有属性和操作，也可以在原有类的基础上作一些修改和增补
  • 新类称为派生类或者子类，原有类称为基类或父类
  • 从形式上来看，派生类更大一些，从逻辑上，看派生类是基类的具体化
    派生类所表示的事务范围要比基类的事务范围要小的多
  • eg：派生类和基类的关系
    在这里插入图片描述

3.公有，私有，保护继承

  • 公有，私有，保护成员
    （1）在关键字public后面声明，它们是类与外部的接口，任何外部函数都可以访问公有类型数据和函数
    （2）在关键字private后面声明，只允许本类中的函数访问，而类外部的任何函数都不能访问
    （3）在关键字protected后面声明，与private类似，其差别表现在继承与派生时，对派生类的影响不同
  • eg：P29\01.cpp
#include <iostream>
using namespace std;class Base
{
public:int x_;
protected:int y_;
private:int z_;
};class PublicInherit : public Base
{
public:void Test(){x_  = 10;//在派生类中可以访问基类的public成员y_ = 20;//在派生类中可以访问基类的protected成员z_ = 30;//在派生类中不能访问基类的private成员，虽然基类的private成员是派生类的一部分}
private:
};int main(void)
{Base b;b.x_ = 20;//类外部可以访问public成员b.z_ = 30;//类外部不能访问protected成员return 0;
}
  • 公有、私有、保护继承的关系
    公有继承：公有和保护成员不变；私有成员任何一种继承都变成了不可直接访问；
    私有继承：公有和保护成员都变成了私有的；
    保护继承：公有成员降级为保护，保护的不变
    在这里插入图片描述

4.默认继承保护级别

class Base {};
struct D1 : Base {};//对于结构体而言，默认是公有继承
class D2 : Base {};//对于类而言，默认是私有继承

5.接口继承与实现继承

  • 我们将类的公有成员函数称为接口
  • 公有继承，基类的公有成员函数在派生类中仍然是公有的。换句话说就是基类的接口成为了派生类的接口，因而将它称为接口继承
  • 实现继承，对于私有、保护继承，派生类不继承基类的接口。
    派生类将不再支持基类的公有接口，它希望能重用基类的实现而已，因而将它称为实现继承

6.继承与重定义

  • 对基类的数据成员的重定义

  • 对基类成员函数的重定义分为2种
    （1）overwrite：称为重定义，重定义会隐藏基类的成员
    与基类完全相同；
    与基类成员函数名相同，参数不同；
    （2）override
    称为：覆盖，要求是虚函数

  • overload：称为重载，发生在：作用域相同，需要在同一个类当中

  • eg1：

#include <iostream>
using namespace std;class Base
{
public:Base() : _x(0){}int GetBaseX() const { return _x; }int x_;
};class Derived : public Base
{
public:// Derived() : _x(0)// {// }// int GetDerivedX() const // { //     return _x; // }// int x_;
};int main(void)
{Derived d;d.x_ = 10;//重定义会隐藏基类的成员,基类的x_=0，派生类的x_=10cout<<d.GetBaseX()<<endl;// cout<<d.GetDerivedX()<<endl;return 0;
}

  • 测试：
    没有重定义的话，改变的就是基类的x_
    在这里插入图片描述

  • eg2：
    在派生类中定义与基类同名的函数，但是带参数

#include <iostream>
using namespace std;class Base
{
public:Base() : _x(0){}int GetBaseX() const { return _x; }int x_;void Show(){cout<<"Base::show..."<<endl;}
};class Derived : public Base
{
public:Derived() : _x(0){}int GetDerivedX() const { return _x; }int x_;void Show(int n){cout<<"Derived::show"<<endl;}};int main(void)
{Derived d;d.x_ = 10;//重定义会隐藏基类的成员,基类的x_=0，派生类的x_=10cout<<d.GetBaseX()<<endl;cout<<d.GetDerivedX()<<endl;d.show();return 0;
}

  • 测试：
    不能直接调用基类的show函数了，基类的show()在派生类中被隐藏了；
    在这里插入图片描述

  • eg3：
    在派生类中定义与基类同名的函数
    调用的是，派生类的不带参数的show方法

#include <iostream>
using namespace std;class Base
{
public:Base() : _x(0){}int GetBaseX() const { return _x; }int x_;void Show(){cout<<"Base::show..."<<endl;}
};class Derived : public Base
{
public:Derived() : _x(0){}int GetDerivedX() const { return _x; }int x_;void Show(int n){cout<<"Derived::show"<<endl;}void Show(){cout<<"Derived::show..."<<endl;}};int main(void)
{Derived d;d.x_ = 10;d.Base::x_ = 20;cout<<d.GetBaseX()<<endl;cout<<d.GetDerivedX()<<endl;//调用的是，派生类的不带参数的show方法d.show();//访问基类的show方法d.Base::show();return 0;
}
  • 测试：
    在这里插入图片描述

7.继承与组合

  • 继承与组合的内存模型，基本是一样的，都是把基类作为派生类的子对象（用子成员描述更加合适）

  • 无论是继承与组合，其本质上都是把子对象放在新类型中，两者都是使用构造函数的初始化列表去构造这些子对象

  • 组合通常是希望：新类内部具有已存在的类的功能时能使用，而不是希望已存在类作为它的接口。
    组合通过嵌入一个对象以实现新类的功能，而新类用户看到的是新定义的接口，而不是来自老类的接口。(has-a)
    组合通常表现为has-a特点：将一个类作为另外一个类的子对象

  • 如果希望新类与已存在的类有相同的接口(在这基础上可以增加自己的成员)。这时候需要用继承，也称为子类型化。（is-a）
    凡是能够接收基类参数，都能用派生类来替换，因为派生类也是一种基类对象，子类型化，子类拥有基类所有的方法，子类继承基类的所有的接口，能够使用基类的地方就能使用子类

  • 里氏代换原则能够检验继承的质量，继承更关注的是行为

  • eg：P29\02.cpp

#include <iostream>
using namespace std;class Base
{
public:Base() : _x(0){}int GetBaseX() const { return _x; }int x_;void Show(){cout<<"Base::show..."<<endl;}
};class Derived : public Base
{
public:Derived() : _x(0){}int GetDerivedX() const { return _x; }int x_;void Show(int n){cout<<"Derived::show"<<endl;}void Show(){cout<<"Derived::show..."<<endl;}};class Test
{
public:Base b_;int x_;
};int main(void)
{Derived d;d.x_ = 10;d.Base::x_ = 20;cout<<d.GetBaseX()<<endl;cout<<d.GetDerivedX()<<endl;//调用的是，派生类的不带参数的show方法d.show();//访问基类的show方法d.Base::show();//Derived继承了Base，相当于把base当成了子对象一样的//Derived包含了2个数据成员：基类的_x,派生类的_xcout<<sizeof(Derived)<<endl;cout<<sizeof(Test)<<endl;return 0;
}
  • 测试：
    在这里插入图片描述

8.私有继承的妙用

private继承导致的结果

  • 基类中的所有成员都会变成private；

  • 如果是private继承，则不会自动将派生类类型转换为基类类型(不会自动转换，但是可以手动显式进行转换)，不能隐式转换；

  • 最大的用处是通过“继承”的纵向逻辑建立了一种“has-a”逻辑（物理上还是“is-a”）。更直白点说，就是从基类继承来的成员，具有对内可用但是对外不可见的特点，这和组合的逻辑很像。所以说，在私有继承的语境下，可以把基类看成派生类的数据成员对象。

private继承的意义

  • 不同于public继承是表示子类与基类之间的’is-a’关系，private并不象征着类之间的’is-a’关系。

  • private继承意味着“子类根据基类的实现而得到”。(implemented-in-terms-of,根据基类实现出子类)

  • 由于private继承将基类的所有public都改为private，因此，可以将private继承视为继承子类的实现而略去子类的接口(因为子类的接口由于private的原因不能再被调用者调用，相当于接口被取消),接口指一个class内的public方法。

什么情况下该/不该使用private继承

  • 由于private就是将一个类(基类)作为另一个类(子类)的一部分实现内容，即用基类来实现子类，它与对象之间的复合/包含关系很像，因此需要明确它们的异同点并考虑替代。
  • 复合/聚合关系：即一个类包含另一个类，如在class Foo中定义一个成员，其类型是另一个类，这两个类之间就是复合关系。

使用private继承来代替复合的情况

  • 存在protected成员的时候，使用private继承和使用复合的结果是不同的：复合后一个类仍然不能使用另一个类的protected成员；而private继承可以。
  • 存在virtual成员的时候：复合与private继承的结果也不同。

总结：什么时候使用private继承比复合更好

  • 当你希望访问protected接口的时候，使用private继承比复合更好，因为private继承能够提供访问权限；
  • 当你希望override它的virtual函数的时候，使用private继承更好，因为继承能够提供override。
  • 除此之外一般来说，使用复合比使用private继承更好。

eg：

class father1;
class father2
{public:void func1(){}
protected:void func2(){}
}//使用继承的逻辑初始化。
class son:private father1, private father2{
public:
//p1是father1构造函数需要的参数，p2同理son(p1,p2):father1(p1),father2(p2){}private:void func3(){func1();func2();}
}

访问基类的方法

  • 可以访问访问基类的public和protected的方法;

访问基类public对象(or 方法)：

  • 如果直接要使用整个基类对象本身怎么做呢？方法是使用强制转换。因为是继承，所以可以这么做。
  • 如：(const father1&) this，这个this指的是派生类。
#include <iostream>class Test {protected:Test() { std::cout << "Test()" << std::endl; }~Test() = default;public:void configure() { std::cout << "configure()" << std::endl; }protected:void func() { std::cout << "func()" << std::endl; }
};class SubTest : private Test {
public:SubTest() : Test() {((Test *)this)->configure();configure();func();}
};
class EmptyClass {};int main() {auto test = SubTest{};std::cout << sizeof(EmptyClass) << std::endl;return 0;
}

访问基类友元函数

  • 跟访问基类对象的方法一样，即强制转换

注：父类的私有虚函数

一个成员函数被定义为private属性，标志着其只能被当前类的其他成员函数(或友元函数)所访问。

而virtual修饰符则强调父类的成员函数可以在子类中被重写，因为重写之时并没有与父类发生任何的调用关系，故而重写是被允许的。

被virtual修饰的成员函数，不论他们是private、protect或是public的，都会被统一的放置到虚函数表中。

对父类进行派生时，子类会继承到拥有相同偏移地址的虚函数表（相同偏移地址指，各虚函数相对于VPTR指针的偏移），则子类就会被允许对这些虚函数进行重载。且重载时可以给重载函数定义新的属性；

  • 例如public，其只标志着该重载函数在该子类中的访问属性为public，和父类的private属性没有任何关系！

  • eg：

class WeatherBase
{
private：virtual void init();
}
class Rain : public WeatherBase
{
private:virtual void init();
}

参考：
private继承的特点和意义以及何时使用；
C++私有继承有什么用、怎么用

这篇关于（P29）继承：代码重用 ，继承 ，公有，私有，保护继承 ，默认继承保护级别 ，接口继承与实现继承 ，继承与重定义 ，继承与组合的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


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

相关文章

SpringBoot3实现Gzip压缩优化的技术指南

SpringBoot3实现Gzip压缩优化的技术指南

《SpringBoot3实现Gzip压缩优化的技术指南》随着Web应用的用户量和数据量增加,网络带宽和页面加载速度逐渐成为瓶颈,为了减少数据传输量,提高用户体验,我们可以使用Gzip压缩HTTP响应,... 目录1、简述2、配置2.1 添加依赖2.2 配置 Gzip 压缩3、服务端应用4、前端应用4.1 N
阅读更多...
SpringBoot实现数据库读写分离的3种方法小结

SpringBoot实现数据库读写分离的3种方法小结

《SpringBoot实现数据库读写分离的3种方法小结》为了提高系统的读写性能和可用性,读写分离是一种经典的数据库架构模式,在SpringBoot应用中,有多种方式可以实现数据库读写分离,本文将介绍三... 目录一、数据库读写分离概述二、方案一：基于AbstractRoutingDataSource实现动态
阅读更多...
Python FastAPI+Celery+RabbitMQ实现分布式图片水印处理系统

Python FastAPI+Celery+RabbitMQ实现分布式图片水印处理系统

《PythonFastAPI+Celery+RabbitMQ实现分布式图片水印处理系统》这篇文章主要为大家详细介绍了PythonFastAPI如何结合Celery以及RabbitMQ实现简单的分布式... 实现思路FastAPI 服务器Celery 任务队列RabbitMQ 作为消息代理定时任务处理完整
阅读更多...
springboot循环依赖问题案例代码及解决办法

springboot循环依赖问题案例代码及解决办法

《springboot循环依赖问题案例代码及解决办法》在SpringBoot中,如果两个或多个Bean之间存在循环依赖（即BeanA依赖BeanB,而BeanB又依赖BeanA）,会导致Spring的... 目录1. 什么是循环依赖？2. 循环依赖的场景案例3. 解决循环依赖的常见方法方法 1：使用 @La
阅读更多...
Java枚举类实现Key-Value映射的多种实现方式

Java枚举类实现Key-Value映射的多种实现方式

《Java枚举类实现Key-Value映射的多种实现方式》在Java开发中,枚举(Enum)是一种特殊的类,本文将详细介绍Java枚举类实现key-value映射的多种方式,有需要的小伙伴可以根据需要... 目录前言一、基础实现方式1.1 为枚举添加属性和构造方法二、http://www.cppcns.co
阅读更多...
使用Python实现快速搭建本地HTTP服务器

使用Python实现快速搭建本地HTTP服务器

《使用Python实现快速搭建本地HTTP服务器》：本文主要介绍如何使用Python快速搭建本地HTTP服务器,轻松实现一键HTTP文件共享,同时结合二维码技术,让访问更简单,感兴趣的小伙伴可以了... 目录1. 概述2. 快速搭建 HTTP 文件共享服务2.1 核心思路2.2 代码实现2.3 代码解读3.
阅读更多...
使用C#代码在PDF文档中添加、删除和替换图片

使用C#代码在PDF文档中添加、删除和替换图片

《使用C#代码在PDF文档中添加、删除和替换图片》在当今数字化文档处理场景中,动态操作PDF文档中的图像已成为企业级应用开发的核心需求之一,本文将介绍如何在.NET平台使用C#代码在PDF文档中添加、... 目录引言用C#添加图片到PDF文档用C#删除PDF文档中的图片用C#替换PDF文档中的图片引言在当
阅读更多...
C#使用SQLite进行大数据量高效处理的代码示例

C#使用SQLite进行大数据量高效处理的代码示例

《C#使用SQLite进行大数据量高效处理的代码示例》在软件开发中,高效处理大数据量是一个常见且具有挑战性的任务,SQLite因其零配置、嵌入式、跨平台的特性,成为许多开发者的首选数据库,本文将深入探... 目录前言准备工作数据实体核心技术批量插入：从乌龟到猎豹的蜕变分页查询：加载百万数据异步处理：拒绝界面
阅读更多...
MySQL双主搭建+keepalived高可用的实现

MySQL双主搭建+keepalived高可用的实现

《MySQL双主搭建+keepalived高可用的实现》本文主要介绍了MySQL双主搭建+keepalived高可用的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,... 目录一、测试环境准备二、主从搭建1.创建复制用户2.创建复制关系3.开启复制，确认复制是否成功4.同
阅读更多...
Java实现文件图片的预览和下载功能

Java实现文件图片的预览和下载功能

《Java实现文件图片的预览和下载功能》这篇文章主要为大家详细介绍了如何使用Java实现文件图片的预览和下载功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... Java实现文件（图片）的预览和下载 @ApiOperation("访问文件") @GetMapping("
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2