【C++继承】

最新推荐文章于 2024-05-31 11:51:41 发布
最新推荐文章于 2024-05-31 11:51:41 发布
阅读量77 收藏
点赞数
分类专栏： C语言 文章标签： c++ java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63746713/article/details/133944004
版权

C++继承

继承

继承是面向对象三大特性之一

有些类与类之间存在特殊的关系，例如下图中：

在这里插入图片描述

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

这个时候我们就可以考虑利用继承的技术，减少重复代码

继承的基本语法

例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同

接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处

普通实现：

//Java页面
class Java 
{
public:
 void header()
 {
  cout << "首页、公开课、登录、注册...（公共头部）" << endl;
 }
 void footer()
 {
  cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
 }
 void left()
 {
  cout << "Java,Python,C++...(公共分类列表)" << endl;
 }
 void content()
 {
  cout << "JAVA学科视频" << endl;
 }
};
//Python页面
class Python
{
public:
 void header()
 {
  cout << "首页、公开课、登录、注册...（公共头部）" << endl;
 }
 void footer()
 {
  cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
 }
 void left()
 {
  cout << "Java,Python,C++...(公共分类列表)" << endl;
 }
 void content()
 {
  cout << "Python学科视频" << endl;
 }
};
//C++页面
class CPP 
{
public:
 void header()
 {
  cout << "首页、公开课、登录、注册...（公共头部）" << endl;
 }
 void footer()
 {
  cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
 }
 void left()
 {
  cout << "Java,Python,C++...(公共分类列表)" << endl;
 }
 void content()
 {
  cout << "C++学科视频" << endl;
 }
};

void test01()
{
 //Java页面
 cout << "Java下载视频页面如下： " << endl;
 Java ja;
 ja.header();
 ja.footer();
 ja.left();
 ja.content();
 cout << "--------------------" << endl;

 //Python页面
 cout << "Python下载视频页面如下： " << endl;
 Python py;
 py.header();
 py.footer();
 py.left();
 py.content();
 cout << "--------------------" << endl;

 //C++页面
 cout << "C++下载视频页面如下： " << endl;
 CPP cp;
 cp.header();
 cp.footer();
 cp.left();
 cp.content();

}

int main() {

 test01();

 system("pause");

 return 0;
}

继承实现：

//公共页面
class BasePage
{
public:
 void header()
 {
  cout << "首页、公开课、登录、注册...（公共头部）" << endl;
 }

 void footer()
 {
  cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
 }
 void left()
 {
  cout << "Java,Python,C++...(公共分类列表)" << endl;
 }

};

//Java页面
class Java : public BasePage
{
public:
 void content()
 {
  cout << "JAVA学科视频" << endl;
 }
};
//Python页面
class Python : public BasePage
{
public:
 void content()
 {
  cout << "Python学科视频" << endl;
 }
};
//C++页面
class CPP : public BasePage
{
public:
 void content()
 {
  cout << "C++学科视频" << endl;
 }
};

void test01()
{
 //Java页面
 cout << "Java下载视频页面如下： " << endl;
 Java ja;
 ja.header();
 ja.footer();
 ja.left();
 ja.content();
 cout << "--------------------" << endl;

 //Python页面
 cout << "Python下载视频页面如下： " << endl;
 Python py;
 py.header();
 py.footer();
 py.left();
 py.content();
 cout << "--------------------" << endl;

 //C++页面
 cout << "C++下载视频页面如下： " << endl;
 CPP cp;
 cp.header();
 cp.footer();
 cp.left();
 cp.content();


}

int main() {

 test01();

 system("pause");

 return 0;
}

总结：

继承的好处： 可以减少重复的代码

class A : public B;

A 类称为子类 或 派生类

B 类称为父类 或 基类

派生类中的成员，包含两大部分：

一类是从基类继承过来的，一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性。

继承方式

继承的语法：class 子类 : 继承方式 父类

继承方式一共有三种：

  • 公共继承
  • 保护继承
  • 私有继承

在这里插入图片描述

示例：

class Father
{
public:
 int a;
protected:
 int b;
private:
 int c;
};
class son1 :public Father
{
public:
 void func()
 {
  a = 10;
  b = 10;
  //c = 10;private不可访问
 }
};
void test01()
{
 son1 s1;
 s1.a = 100;
 //s1.b = 20;protected不可访问
 //c根本就没有
}
class son2 :protected Father
{
public:
 void funa()
 {
  a = 20;
  b = 20;
  //c = 10;
 }

};
void test02()
{
 son2 s2;
 //s2.a = 100;protected不可访问
 //s2.b = 100;protected不可访问
 //c根本就没有
}
class son3 :private Father
{
public:
 void func()
 {
  a = 10;
  b = 10;
  //c = 10;不可访问
 }
};
void test03()
{
 son3 s3;
 //s2.a = 100;private不可访问
 //s2.b = 100;private不可访问
 //c根本就没有
}
class grandson3 :public son3
{
public:
 void fund()
 {
  //a = 30;因为在son3中只有ab两个变量
  //b = 30;且他们ab变量为私有的
  //c = 30;所以公共的grand继承是连定义都没有了
 }
};

继承中的对象模型

问题： 从父类继承过来的成员，哪些属于子类对象中？

示例：

class Base
{
public:
 int m_A;
protected:
 int m_B;
private:
 int m_C; //私有成员只是被隐藏了，但是还是会继承下去
};

//公共继承
class Son :public Base
{
public:
 int m_D;
};

void test01()
{
 cout << "sizeof Son = " << sizeof(Son) << endl;
}

int main() {

 test01();

 system("pause");

 return 0;
}

结论： 父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造和析构顺序是谁先谁后？

示例：

class Base 
{
public:
 Base()
 {
  cout << "Base构造函数!" << endl;
 }
 ~Base()
 {
  cout << "Base析构函数!" << endl;
 }
};

class Son : public Base
{
public:
 Son()
 {
  cout << "Son构造函数!" << endl;
 }
 ~Son()
 {
  cout << "Son析构函数!" << endl;
 }

};


void test01()
{
 //继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
 Son s;
}

int main() {

 test01();

 system("pause");

 return 0;
}

运行结果：

Base构造函数!
Son构造函数!
Son析构函数!
Base析构函数!

总结：继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域

示例：

#include<iostream>
#include<string>
using namespace std;
class father
{
public:
 int m_a = 100;
 void func()
 {
  cout << "father func" << endl;
 }
};
class son :public father
{
public:
 int m_a = 200;
 void func()
 {
  cout << "son func" << endl;
 }
};
int main()
{
 son s1;
 cout << "s1.m_a=" << s1.m_a << endl;
 cout << "s1.father::m_a=" << s1.father::m_a << endl;
 s1.func();
 s1.father::func();
 //如果father中有func（int）是直接调用不了的要加father::
 /*
 子类产生了重名的函数会将父类中的此名字的函数全部屏蔽
 包括重载的函数。所以需要加作用域，来将此隐藏去除。
 */
}

总结：

  1. 子类对象可以直接访问到子类中同名成员
  2. 子类对象加作用域可以访问到父类同名成员
  3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加 作用域可以访问到父类中同名函数

继承同名静态成员处理方式

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域

示例：

class Base {
public:
 static void func()
 {
  cout << "Base - static void func()" << endl;
 }
 static void func(int a)
 {
  cout << "Base - static void func(int a)" << endl;
 }

 static int m_A;
};

int Base::m_A = 100;

class Son : public Base {
public:
 static void func()
 {
  cout << "Son - static void func()" << endl;
 }
 static int m_A;
};

int Son::m_A = 200;

//同名成员属性
void test01()
{
 //通过对象访问
 cout << "通过对象访问： " << endl;
 Son s;
 cout << "Son  下 m_A = " << s.m_A << endl;
 cout << "Base 下 m_A = " << s.Base::m_A << endl;

 //通过类名访问
 cout << "通过类名访问： " << endl;
 cout << "Son  下 m_A = " << Son::m_A << endl;
 cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

//同名成员函数
void test02()
{
 //通过对象访问
 cout << "通过对象访问： " << endl;
 Son s;
 s.func();
 s.Base::func();

 cout << "通过类名访问： " << endl;
 Son::func();
 Son::Base::func();
 //出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
 Son::Base::func(100);
}
int main() {

 //test01();
 test02();

 system("pause");

 return 0;
}

运行结果：

通过对象访问：
Son - static void func()
Base - static void func()
通过类名访问：
Son - static void func()
Base - static void func()
Base - static void func(int a)

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）

多继承语法

C++允许一个类继承多个类

语法：class 子类 ：继承方式 父类1 ， 继承方式 父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

示例：

#include<iostream>
#include<string>
using namespace std;
class father1
{
public:
 int m_a=10;
 int m_b=20;
 int aa = 66;
};
class father2
{
public:
 int m_c = 30;
 int m_d = 40;
 int aa = 66;
};
class son :public father1, private father2
{
public:
 int m_d = 50;
};
int main()
{
 son s1;
 cout << s1.m_a << endl;
 cout << s1.m_b << endl;
 cout << s1.m_d << endl;
 //可以访问的是自己的和公有的f1
 cout<<"sizeof(s1)="<<sizeof(s1)<<endl;
 //有7个成员，1个自己的3个f1公有继承，3个f2私有继承
 
 //cout << s1.aa << endl;不可以，两个父类都有指代不明
 //需要使用作用域符号
 cout << s1.father1::aa << endl;
}

总结： 多继承中如果父类中出现了同名情况，子类使用时候要加作用域

菱形继承

菱形继承概念：

​ 两个派生类继承同一个基类

​ 又有某个类同时继承者两个派生类

​ 这种继承被称为菱形继承，或者钻石继承

典型的菱形继承案例：

在这里插入图片描述

菱形继承问题：

  1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。

  2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

示例：

class Animal
{
public:
 int m_Age;
};

//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo   : virtual public Animal {};
class SheepTuo : public Sheep, public Tuo {};

void test01()
{
 SheepTuo st;
 st.Sheep::m_Age = 100;
 st.Tuo::m_Age = 200;

 cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
 cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
 cout << "st.m_Age = " << st.m_Age << endl;
}
//最后输出的值是最后的值或者改变的那个值

总结：

  • 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
  • 利用虚继承可以解决菱形继承问题

参考

本文参照黑马程序员C++B站课程

小闫同学.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 继承详解
TABE_的博客
02-21 1万+
C++ 继承继承语法继承方式改变访问权限名字遮蔽继承时的对象模型无变量遮蔽有变量遮蔽 继承语法 继承的一般语法为： class 派生类名:［继承方式］ 基类名{ 派生类新增加的成员 }; 继承方式 继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。不同的继承方式会影响基类成员在派生类中的访问权限。 （1）public继承方式 基类中所有 public 成员在派生类中为 public 属性； 基类中
C++继承详解
DR5200的博客
10-14 2486
文章目录一.继承的概念和定义二.基类和派生类对象赋值转换三.继承中的作用域四.派生类的默认成员函数五.继承和友元六.继承与静态成员七.菱形继承及菱形虚拟继承八.C++编译器如何通过虚继承解决数据冗余和二义性 一.继承的概念和定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的
C++继承
彧玊的博客
12-20 1768
C++继承相关的基础知识
C++ 继承
weixin_44212838的博客
07-23 1465
inheritance)机制是面向对象程序设计的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用。.........
C++继承的使用
JayceSun的博客
04-17 1769
定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 ...
C++继承[万字详解]
weixin_47257473的博客
03-16 3413
本文非常详细介绍了C++中的继承，包括继承的定义，介绍，方式。以及继承后派生类构造函数和析构函数的调用顺序，继承中的切片等问题，继承后静态成员，友元关系的变化，以及多继承中的菱形继承和菱形虚拟继承，对继承的一些总结。继承和组合的介绍以及关系.
C++继承方式
m0_50313114的博客
05-20 829
C++继承分为，公有(public)、保护(protected),私有(private)三种继承方式， 公有继承：基类共有成员（函数、属性）、保护成员在派生类中依旧为共有成员、保护成员；基类私有成员物理上在派生类中继承了，不过不能通过派生类对象（指针、引用）访问，只能通过基类中公有函数来间接访问基类私有成员。 保护继承：基类共有成员（函数、属性）、保护成员在派生类中均为在派生类中“”保护成员，私有成员在“派生类中不可见”，可通过基类共有函数间接访问。 私有继承：基类公有、保护、私有在派生类中均“不可见
c++ 继承构造函数
SWX230162的博客
10-11 4903
c++ 继承构造函数 class TestA { public: TestA(string i): a(i) {} ~TestA() {} string geta() { return a; } virtual string getb() = 0; private: string a; }; class TestB: public TestA{ public: TestB(string i):TestA(i),b(i) {}
c++继承
小陈的博客
04-19 4355
目录继承继承方式父类和子类对象赋值转换 继承 继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。 继承不仅继承父类的成员变量，还继承父类的成员函数 继承是类设计层次的复用 简单来说，继承就是让子类使用父类的成员 class Person//父类 { public: void print() { cout << "name:" << _name << endl; cout
C++ 继承方式
gxt_kt的博客
01-19 1185
C++ 继承方式 文章目录C++ 继承方式一、了解继承方式首先需要了解类的权限：二、继承时权限的变化1.公共继承2.保护继承3.私有继承三、代码理解四、深入研究，加深理解五、全部代码（由于故意写出错误帮助理解，编译通不过） 继承方式： 1.公共继承。2.保护继承。3.私有继承 用法： class 子类 : 继承方式 父类{ 内容 } 一、了解继承方式首先需要了解类的权限： public:类内类外都能访问 protected/private:类内能访问，类外不能访问 二、继承时权限的变化 1.公共继承 p
C++继承介绍
09-05
C++继承可以是单一继承或多重继承，每一个继承连接可以是public,protected,private也可以是virtual或non-virtual
详解c++ 继承
08-18
主要介绍了c++ 继承的相关资料，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
C++ 继承详解及实例代码
12-31
C++继承可以是单一继承或多重继承，每一个继承连接可以是public,protected,private也可以是virtual或non-virtual。然后是各个成员函数选项可以是virtual或non-virtual或pure virtual。本文仅仅作出一些关键点的验证...
c++继承分类
04-28
在Qt中编写的c++继承分类的视频
C++：round函数用法
Solititude的博客
05-28 339
C++：round函数用法
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 813
string类各函数接口。
【如何在Qt C++中使用SSL和TLS加密传输数据？】
m0_45463480的博客
05-28 187
在这个示例中，我们创建了一个简单的Qt应用程序，向指定的HTTPS地址发送请求，并显示响应。信号来处理响应数据。您可以从响应中读取数据并进行进一步处理。来配置SSL/TLS连接，包括对证书进行验证和加密要求等。为您要访问的实际URL，并根据需要进一步配置SSL策略。在发送请求之前，可设置SSL配置。确保您的Qt项目已经链接了网络模块（对象发送网络请求，并接收响应。对象指定要访问的URL。
C语言——指针
最新发布
weixin_45725380的博客
05-31 630
存储类型 数据类型 *指针变量名；例如：int *p;//定义了一个整数型指针变量pint a=5;int *p=&a;char b='v';char *q=&b;访问指针所指的空间里的内容时，需要用取内容运算符*来获取此时，变量p存放的就是a的地址，变量q存放的就是b的地址；符号*可以访问地址指向的空间里面的内容。指针与变量之间的关系如下：int i=3;本质还是指针，指向的是数组。（又称为行指针）所谓指针数组就是由若干个具有相同类型的指针变量组成的集合。
c++ 继承java类
01-12
C++可以继承Java类，但是需要注意一些细节和差异。在C++中，可以使用关键字`class`来定义一个类，并使用关键字`public`来指定继承关系。下面是一个示例： ```cpp class JavaClass { public: void javaMethod() { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值