C++学习笔记（十五）

已于 2023-12-18 15:29:05 修改
阅读量370 收藏 9
点赞数 9
分类专栏： C++ 文章标签： 学习 笔记 c++ 算法 开发语言
于 2023-12-18 14:10:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zh20001109zh/article/details/135057493
版权

继承

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

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

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

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

1. 继承的基本语法

例如我们看到很多的网站中，都有公共的头部、公共的底部、甚至公共的左侧列表，只有中心内容不同，接下来分别使用普通写法和继承写法来实现网页中的内容

普通写法（98行）：

#include <iostream>

using namespace std;

// 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 test()
{
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "---------------------------------" << endl;

	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "---------------------------------" << endl;

	CPP cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();	
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

继承写法（80行）：

#include <iostream>

using namespace std;

// 公共页面
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 test()
{
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "---------------------------------" << endl;

	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "---------------------------------" << endl;

	CPP cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();	
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

总结：

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

语法：class A :public B

A类  称为子类  也称为  派生类

B类  称为父类  也称为  基类

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

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

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

2. 继承方式

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

继承的方式一种有三种：

1. 公共继承

2. 保护继承

3. 私有继承

3. 继承中的对象模型

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

利用开发人员命令提示工具查看对象模型

1. 找到要查看的类的文件所在的路径

2. cd到此路径下

3. 查看类的名字和文件的名字

4. cl /d1 reportSingleClassLayout类名 文件名

4. 继承中构造和析构的顺序

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

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

#include <iostream>

using namespace std;

class Dad
{
public:
	Dad()
	{
		cout << "父类的构造函数......" << endl;
	}
	~Dad()
	{
		cout << "父类的析构函数......" << endl;
	}
};

class Son :public Dad
{
public:
	Son()
	{
		cout << "子类的构造函数......" << endl;
	}
	~Son()
	{
		cout << "子类的析构函数......" << endl;
	}
};

void test()
{
	Son son;
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

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

5. 继承同名成员的处理方式

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

访问子类同名成员 直接访问即可

访问父类同名成员 需要加作用域

#include <iostream>

using namespace std;

class Dad
{
public:
	int m_a;
	Dad()
	{
		m_a = 10;
	}
	void func()
	{
		cout << "Dad中func()的调用..." << endl;
	}
	void func(int a)
	{
		cout << "Dad中func(int a)的调用..." << endl;
	}
};

class Son :public Dad
{
public:
	int m_a;
	Son()
	{
		m_a = 20;
	}
	void func()
	{
		cout << "Son中func()的调用..." << endl;
	}
};

void test()
{
	Son son;
	cout << son.m_a << endl; // 直接调用 调用的是子类中的同名成员属性
	cout << son.Dad::m_a << endl; // 调用父类中的同名成员属性需要加作用域
	
	son.func(); // 直接调用 调用的是子类中的同名成员函数
	son.Dad::func(); // 调用父类中的同名成员函数需要加作用域

	// 如果子类中出现和父类同名的成员函数，子类的同名成员函数会隐藏掉父类中所有同名成员函数
	// 如果想访问到父类中被隐藏的同名成员函数，需要加作用域
	son.Dad::func(100);
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

总结：

1. 子类对象可以直接访问到子类中同名成员

2. 子类对象加作用域可以访问到父类同名成员

3. 当子类和父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

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

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

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

访问子类同名成员 直接访问即可

访问父类同名成员 需要加作用域

#include <iostream>

using namespace std;

class Dad
{
public:
	static int m_a;
	static void func()
	{
		cout << "Dad:static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Dad:static void func(int a)" << endl;
	}
};
int Dad::m_a = 100;

class Son :public Dad
{
public:
	static int m_a;
	static void func()
	{
		cout << "Son:static void func()" << endl;
	}
};
int Son::m_a = 200;
void test()
{
	// 1. 通过对象访问
	cout << "通过对象访问:" << endl;
	Son son;
	cout << "Son中的m_a=" << son.m_a << endl;
	cout << "Dad中的m_a=" << son.Dad::m_a << endl;

	// 2. 通过类名访问
	cout << "通过类名访问:" << endl;
	cout << "Son中的m_a=" << Son::m_a << endl;
	// 第一个::代表通过类名方式访问 第二个::代表访问父类作用域下
	cout << "Dad中的m_a=" << Son::Dad::m_a << endl;

	// 1. 通过对象访问
	cout << "通过对象访问:" << endl;
	son.func();
	son.Dad::func();
	son.Dad::func(100);

	// 2. 通过类名访问
	Son::func();
	// 第一个::代表通过类名方式访问 第二个::代表访问父类作用域下
	Son::Dad::func();
	Son::Dad::func(100);
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

7. 多继承语法

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

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

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

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

#include <iostream>

using namespace std;

class Base1
{
public:
	int m_a;
	int m_b;
	Base1()
	{
		m_a = 100;
		m_b = 200;
	}
};

class Base2
{
public:
	int m_a;
	int m_c;
	Base2()
	{
		m_a = 1000;
		m_c = 300;
	}
};

class Son :public Base1, public Base2
{
public:
	int m_d;
	Son()
	{
		m_d = 400;
	}
};

void test()
{
	Son s;
	cout << "Base1:m_a=" << s.Base1::m_a << endl;
	cout << "Base2:m_a=" << s.Base2::m_a << endl;
	cout << "m_b=" << s.m_b << endl;
	cout << "m_c=" << s.m_c << endl;
	cout << "m_d=" << s.m_d << endl;
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

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

8. 菱形继承

菱形继承概念：

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

又有某个类同时继承这两个类

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

菱形继承的问题：

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

2. 草泥马继承自动物的数据继承了两份，但其实这份数据只需要一份就可以

#include <iostream>

using namespace std;

// 动物类
class Animal
{
public:
	int m_age;
};

// 羊类
class Sheep:public Animal{};

// 驼类
class Camel:public Animal{};

// 羊驼类
class Alpaca :public Sheep, public Camel{};

void test()
{
	Alpaca alpaca;
	alpaca.Sheep::m_age = 18;
	alpaca.Camel::m_age = 28;
	// 当菱形继承时，两个父类拥有相同数据，需要加以作用域进行区分
	cout << "alpaca.Sheep::m_age = " << alpaca.Sheep::m_age << endl; // 18
	cout << "alpaca.Camel::m_age = " << alpaca.Camel::m_age << endl; // 28
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

这份数据只要一份就可以，菱形继承导致数据有两份，产生资源浪费

利用虚继承可以解决菱形继承的问题

在继承之前加上关键字virtual变成虚继承

Animal类被称为虚基类

#include <iostream>

using namespace std;

// 动物类
class Animal
{
public:
	int m_age;
};

// 羊类
class Sheep:virtual public Animal{};

// 驼类
class Camel:virtual public Animal{};

// 羊驼类
class Alpaca :public Sheep, public Camel{};

void test()
{
	Alpaca alpaca;
	alpaca.Sheep::m_age = 18;
	alpaca.Camel::m_age = 28;
	// 当菱形继承时，两个父类拥有相同数据，需要加以作用域进行区分
	cout << "alpaca.Sheep::m_age = " << alpaca.Sheep::m_age << endl; // 28
	cout << "alpaca.Camel::m_age = " << alpaca.Camel::m_age << endl; // 28
	cout << "m_age = " << alpaca.m_age << endl; // 28
}

int main(int argc, char* argv[])
{
	test();
	return 0;
}

继承了两份指针，两份指针都指向同一份内容

总结：

1. 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义

2. 利用虚继承可以解决菱形继承问题

不懂编程的大学生
关注
  • 9
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 7万+
C/C++学习路线总结与分享
黑马程序员C++学习笔记
weixin_46015291的博客
05-31 4710
C++基础入门 1 C++初识 1.1 第一个C++程序 编写一个C++程序总共分为4个步骤 创建项目 创建文件 编写代码 运行程序 1.1.1 创建项目 ​ Visual Studio是我们用来编写C++程序的主要工具，我们先将它打开 1.1.2 创建文件 右键源文件，选择添加->新建项 给C++文件起个名称，然后点击添加即可。 1.1.3 编写代码 #include<iostream> using namespace std; int main() { cout &
C++学习笔记
ftm_csdn的博客
04-16 4322
C++是C语言的超集。
z3 C++学习笔记
T_T233333333的博客
03-06 3161
因为项目需要使用z3库来解决问题，所以自己学习了一下，结果发现网上教程比较少，而且大部分都是使用Python，而我本人是C++的忠实信徒，在知道C++也可以使用z3库以后我毫不犹豫地着手用C++使用z3，但是我很快发现，网上基本没有关于C++使用z3的教程（中文社区一点都没有），因此我记录一下我自己的学习过程希望能够帮助到其他学习的人。 教程链接 网上现有的有三个教程： 官方example.cpp文档：https://github.com/Z3Prover/z3/blob/master/examples.
C++学习笔记（二十四）：c++ this
qq_16701727的博客
01-05 984
【代码】C++学习笔记（二十四）：c++ this。
UE C++学习笔记
weixin_44212242的博客
05-16 3112
UE C++入门级程序编制笔记，基础中的基础，了解UE C++的书写规范和一般要求，实现蓝图，C++混合开发。
C++详细学习笔记（一）
热门推荐
好学的小李的博客
06-09 1万+
首先，本次学习主要参考的书籍是C++Primer Plus第六版，为了方便今后参阅，故写下该学习笔记。 C++是在C语言基础上开发的一种集面向对象编程、泛型编程和过程化编程于一体的编程语言，是C语言的超集。 一、预备知识 C++有三件法宝：1、继承了C语言高效、简洁、快速和可移植性的传统（C代表的过程性编程）；2、面向对象的特性带来了全新的编程方法，这种方法是为了应付复杂程......
C++学习笔记（1）
m0_53005929的博客
01-19 6004
C++学习笔记（1）
《Essential C++》学习笔记
m0_50816320的博客
02-17 3650
书籍介绍 大名鼎鼎的《C++ Primer》作者为了照顾想快速入门C++的"初学者"而编写的入门书籍，全书不足300页却包含C++的大量重要知识，关于此书的由来读者可以自行去阅读此书的前言，这里不再赘述。 此文由来 关于这个文章，其实也是我自己给我的一个挑战，这本书虽然精简，短短不足300页，但是大量的语法，原理一笔带过，很难在几句话的功夫理解一类知识的思想，换句话说，《C++ Primer》太长，很多人读不下去，而这本书太短，又需要一定的注解，解释来辅助理解，所以这篇文章由此诞生，我希望通过这个机会，让
【C++学习笔记】头文件详解
weixin_45695709的博客
05-03 3698
个人整理学习用，非教材，有错误欢迎指正 目录头文件成员变量参数本地变量 头文件   究竟什么是头文件？   首先说明一个概念，所谓的文件后缀并不是必须的，在Linux下这种特点尤为明显。对于编译器来说，无论是.c文件 .cpp文件，抑或是.h文件，都是同一种文件形式，区别仅仅是你去执行该文件的方式。 上图是在Linux环境中编译一个.cpp文件 当使用 g++编译器时，a.cpp被视为一个CPP文件，可以正常编译，编译后的文件也能被正常运行。但使用gcc编译器编译时，gcc会把a.cpp视为一个C文件，
C++学习笔记.pdf
08-12
C++学习笔记
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
c++学习笔记.pdf
07-12
c++学习笔记.pdf
C++学习笔记 C++学习笔记
08-06
C++学习笔记
FME学习之旅---day27
summer_corner的博客
05-17 213
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
使用多实例学习进行乳腺癌组织病理学图像分类和定位
qq_47896523的博客
05-16 1120
乳腺癌是女性最主要的死亡原因，病理学家根据病理切片中观察到的各种视觉特征（例如细胞核的形态特征、细胞核的微观和宏观结构等）做出决定。计算机辅助诊断（CAD）系统可以帮助病理学家自动做出决策。卷积神经网络是最广泛使用的深度学习框架，用于学习图像类别之间的复杂判别特征。多年来，VGG16 [3] 和 ResNet18 [4] 等各种 CNN 架构在海量 ImageNet 数据集上产生了出色的结果。CNN 被用于医学图像以产生最先进的结果。为图像中存在的所有类别提供了定位信息。
学习kong官方文档
好好学习日记
05-17 283
当然，我会用更简洁的方式重新解释这两个概念：Helm和Kubectl是Kubernetes生态系统中常用的两个工具，它们各自有不同的用途：
C语言查漏补缺学习【精简版】
最新发布
qq_49288362的博客
05-18 631
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
零基础c++学习笔记pdf
05-16
《零基础C语言学习笔记》pdf是一份非常好的学习材料。该pdf对C语言进行了系统的介绍，并且从最基础的内容开始进行讲解，适合于零基础的初学者学习。尤其是对于那些没有编程经验的人，该pdf提供了很多实用的示例和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不懂编程的大学生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值