08学习笔记：C++类和对象 -- 继承

于 2024-08-29 14:59:14 发布
阅读量779 收藏 9
点赞数 19
分类专栏： C++系统篇 文章标签： 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74209413/article/details/141497991
版权

1、继承

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

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

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

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

1.1继承的基本语法

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

普通实现：

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

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

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

};

我们可以发现，普通实现中存在很多重复代码，代码简洁性不足，这时我们可以通过继承来减少重复代码

继承实现：

#include <iostream>
using namespace std;

//继承实现页面
class BasePage
{
	public:
	void header()
	{
		cout << "首页、公共课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
	}
	void left()
	{
		cout << "Python、Java、C++、...（公共分类列表）" << endl;
	}

};
//继承的好处：减少重复代码
//语法：class 子类 : 继承方式 父类
//子类 也称为 派生类
//父类 也成为 基类
//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()
{
	cout << "Java下载视频页面如下：" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "----------------------------" << endl;
	cout << "Python下载视频页面如下：" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "----------------------------" << endl;
	cout << "C++下载视频页面如下：" << endl;
	CPP cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();
	cout << "----------------------------" << endl;

}

int main()
{  
	test01();

	system("pause");
	return 0;
}

总结：

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

class A : public B;

A类称为子类 或 派生类

B类称为父类 或 基类

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

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

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

1.2继承方式

继承方式一共有三种：

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

无论哪种继承方式，父类的私有属性子类永远无法访问，

公共继承中，父类的公共权限依然是子类的公共权限，保护权限依然是保护权限；

保护继承中，父类的公共权限和保护权限都是子类的保护权限；

私有继承中，父类的公共权限、保护权限都是子类的私有权限。

#include <iostream>
using namespace std;

//继承方式

//公共继承
class Base1
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son1 :public Base1
{
public:
	void func()
	{
		m_A = 10; //父类中的公共权限成员到子类中依然是公共权限
		m_B = 10; //父类中的保护权限成员到子类中依然是保护权限
		//m_C = 10; //父类在的私有权限成员 子类访问不到
	}
};
void test01()
{
	Son1 s1;
	s1.m_A = 100;
	//s1.m_B = 100; //父类在子类中继承的保护权限依然是保护权限，类外不可访问
}
//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2 :protected Base2
{
public:
	void func()
	{
		m_A = 10;//父类中公共成员，到子类中变为保护权限
		m_B = 10;//父类中保护成员，到子类中变为保护权限
		//m_C = 10; //父类中的私有成员 子类访问不到
	}

};
void test02()
{
	Son2 s1;
	//s1.m_A = 100; //在Son2中 m_A变为保护权限 类外无法访问
	//s1.m_B = 100; //在Son2中 m_B为保护权限 类外无法访问
}
//私有继承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3 :private Base3
{
public:
	void func()
	{
		m_A = 100; //父类中公共成员 变为子类私有成员
		m_B = 100; //父类中保护成员 变为子类私有成员
		//m_C = 100; //父类中私有成员，子类无法访问
	}
};
void test03()
{
	Son3 s1;
	//s1.m_A = 1000; //到Son3中变为私有成员 类外无法访问
	//s1.m_B = 1000; //到Son3中变为私有成员 类外无法访问
}
//孙子类 作用：验证子类私有继承父类的公共、保护权限，是否变为自身的私有成员
class GrandSon3:public Son3
{
public:
	void func()
	{
		//m_A = 10; //类外无法访问子类的m_A，为私有权限
		//m_B = 10; //类外无法访问子类的m_B，为私有权限
	}
};
int main()
{  
	test01();

	system("pause");
	return 0;
}

1.3继承中的对象模型

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

#include <iostream>
using namespace std;

//继承中的对象模型
class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son :public Base
{
public:
	int m_D;
};
void test01()
{
	Son s;
	//16
	//父类中所有非静态成员属性都会被子类继承下去
	//父类中私有成员属性 是被编译器给隐藏了，因此是访问不到，但是确实被继承下去了
	cout << "size of Son = " << sizeof(s) << endl; //16
}

int main()
{  
	test01();

	system("pause");
	return 0;
}

总结：从父类中继承下来的非静态成员属性都属于子类对象的成员，父类中的私有成员属性会被编译器隐藏，但还是会被继承下去。

1.4继承中构造和析构顺序

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

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

示例：

#include <iostream>
using namespace std;

//继承中的构造和析构的顺序
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()
{
	//Base b;
	Son s;
}

int main()
{  
	test01();

	system("pause");
	return 0;
}

以上代码结果：

结论：

继承中的构造和析构顺序如下：
先构造父类再构造子类，析构的顺序与构造的顺序相反。

1.5继承同名成员处理方式

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

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

示例：

#include <iostream>
using namespace std;

//继承中同名成员处理
class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "Base - func()调用 " << endl;
	}
	void func(int a)
	{
		cout << "Base - func(int a)调用 " << endl;
	}
	int m_A;
};
class Son :public Base
{
public:
	Son()
	{
		m_A = 200;
	}
	void func()
	{
		cout << "Son - func()调用 " << endl;
	}
	int m_A;
};
//同名属性处理方式
void test01()
{
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;
}
//同名函数处理方式
void test02()
{
	Son s;
	s.func(); //直接调用 调用是子类中的同名成员

	//如何调用父类中同名成员
	s.Base::func();
	//如果子类中出现与父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
	//s.func(100);
	//如果想访问到父类中被隐藏的同名成员函数，需要加作用域
	s.Base::func(100);
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

结论:

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

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

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

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

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

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

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

示例：

#include <iostream>
using namespace std;

//继承中同名静态成员处理
class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	static void func()
	{
		cout << "Base - static void func()调用 " << endl;
	}
	static void func(int a)
	{
		cout << "Base - func(int a)调用 " << endl;
	}
	//所有对象共享同一份数据 类内声明 类外初始化
	static int m_A;
};
//类外初始化
int Base::m_A = 100;

class Son :public Base
{
public:
	Son()
	{
		m_A = 200;
	}
	static void func()
	{
		cout << "Son - static void func()调用 " << endl;
	}
	static int m_A;
};
int Son::m_A = 200;
//同名静态属性
void test01()
{
	//1、通过对象访问
	cout << "通过对象访问：" << endl;
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;
	//2、通过类名访问
	cout << "通过类名访问:" << endl;
	cout << "Son  下 m_A = " << Son::m_A << endl;
	//第一个::代表通过类名方式访问 第二个::代表访问父类作用域下
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;

}
//同名静态函数
void test02()
{
	//1、通过对象访问
	cout << "通过对象访问：" << endl;
	Son s;
	s.func(); //直接调用 调用是子类中的同名静态成员
	s.Base::func(); //调用父类中静态同名成员
	//2、通过类名访问
	cout << "通过类名访问：" << endl;
	Son::func();
	//第一个::表示通过类名访问，第二个::表示Base的作用域
	Son::Base::func();
	//子类出现和父类同名静态成员函数，也会隐藏掉父类中所有同名成员函数
	//如果想访问父类中的静态同名成员，需要加作用域
	Son::Base::func(100);
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象和通过类名），而非静态成员引用必须与特定对象相对，只有一种访问方式。

1.7多继承语法

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

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

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

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

示例：

#include <iostream>
using namespace std;

//多继承语法
class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}

	int m_A;
};
class Base2
{
public:
	Base2()
	{
		m_A = 200;
	}
	int m_A;
};
class Son :public Base1,public Base2
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}

	int m_C;
	int m_D;
};

void test01()
{
	Son s;
	cout << "size of Son = " << sizeof(s) << endl;  //16
	//当父类间出现同名的成员，需要加作用域
	cout << "Base1::m_A = " << s.Base1::m_A << endl;
	cout << "Base2::m_A = " << s.Base2::m_A << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

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

1.8菱形继承

菱形继承概念：

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

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

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

菱形继承问题：
1）羊继承了动物的数据，驼同样继承了动物的数据，当羊驼使用数据时，就会产生二义性；

2）羊驼继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以了

#include <iostream>
using namespace std;

//动物类
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 = 18;
	st.Tuo::m_Age = 28;
	//当菱形继承，两个父类拥有相同数据，需要加以作用域区分
	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;
	//这份数据我们知道，只有一份就可以了，菱形继承导致数据有两份，资源浪费

}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：

  • 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
  • 利用虚继承可以解决菱形继承问题
御风_21
关注
  • 19
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习笔记 - 阶段三：C++核心编程 - Chapter8：类和对象-继承
家有仙妻谢掌柜的博客
10-24 2865
C++学习笔记 - 阶段三：C++核心编程 - Chapter8：类和对象-继承
C++笔记：类和对象(二)-＞继承
qq_58240849的博客
04-29 613
C++继承的基础知识，以及设计C++代码时关于继承的注意事项
C++学习笔记“类和对象”：继承；
qq_50259950的博客
06-05 669
C++学习笔记“类和对象”：继承；继承的基本语法；继承方式；继承中的对象模型；继承中构造和析构顺序；继承同名成员处理方式；继承同名静态成员处理方式；多继承语法；菱形继承
C++学习笔记（四）：类与对象--友元与继承
太白的博客
09-27 2008
友元函数 类的友元函数一般定义在类外部，可以是定义在全局的函数，也可以是其他类的成员函数，但他们有权访问类的所有私有（private）成员和保护（protected）成员。 尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。 友元定义在全局的函数 //类声明 class example_A { private: //私有成员 int a; //成员 int b; //成员 friend void Fren
C++深度解析教程笔记7-类和对象
qq_35429166的博客
05-02 2090
int weight;int salary;int weight;Boy b;g.print();b.age = 19;b.print();return 0;
C++Primer(第5版)学习笔记：第2章-变量和基本类型
Aeadlied的博客
02-23 918
C++Primer(第5版)学习笔记：第2章-变量和基本类型
笔记：C++学习之旅---初识C++
那时风起
08-24 574
笔记：C++学习之旅---初识C++          博主也是一个新手，学习编程才一年左右，刚大学毕业不久，以前在学校学习的语言主要是C，本人是从嵌入式学起的！我现在从事的公司主要是C++，所以我也开始了自学之路，以下是我学习过程的一些笔记，有的是截取书上的，有的是自我总结的，出现一些错误也请见谅，同时也是为了激励我自己以及和大家一起学习！！！ C：面向结构化（或者说
C++学习笔记：C++基础语法+编程思想
一只努力学习的小碗~
06-27 1899
C++学习笔记，包含C++基础语法、编程思想等
C++学习笔记（十二）------is_a关系（继承关系）
争做图书馆扫地僧的小白的博客
12-17 1010
随着技术的革新，出现各种各样的编程语言，C++就是其中之一，作为最受欢迎的编程语言之一，C++带给开发者们最大的惊喜便是其强大的特性。一方面跟C兼容，可以直面系统底层API，SDK，另一方面提供了很多范式，足够的抽象能力，面向对象，操作符重载，模板等。本篇将讲解最为重要的一种关系即is_a关系（继承关系）。
Qt学习笔记04：创建按钮类--QPushButton
被一个OIER遗弃的一堆烂代码
05-09 2479
☁️前几天学习Qt没找到好的资源，停了一会，挺难的，比Python的Wx和Tk都要难，昨天晚上去B站找到了资源，还有脚本之家的一些文档还有C语言中文网的。 资源： 哔哩哔哩：https://www.bilibili.com/video/BV1g4411H78N?p=6看得人挺多 C语言中文网：http://c.biancheng.net/qt/ 脚本之家：http://shouce.jb51.net/qt-beginning/ ...
P127~134C++类和对象继承学习笔记.docx
04-13
C++类和对象继承学习笔记 本文档主要讲解C++类和对象继承的基本语法和应用，通过继承技术减少重复代码，实现代码的重用和简洁。 继承是面向对象三大特性之一，用于描述类与类之间的特殊关系。例如，在实现网页中的...
java第六章学习笔记:对象和类---java世界的细胞
Enetaunt的博客
03-12 385
【因为每一章都篇幅比较长（10多页，难免有的地方会写错字，如发现请指正，本人不胜感激）】 本章介绍面向对象理念以及如何通过类创建对象 6.1 面向对象概述 主要包括面向对象诞生，面向过程与面向对象程序设计思想的对比，面向对象技术的背景和特点； 提示：面向对象（Object Oriented简称oo）java是完全面向对象语言 6.1.1 面对对象程序设计思想的诞生 【对象不再仅仅与名词...
学习笔记：c++重载和继承
帅泽泽的博客
08-01 722
一、 运算符重载 1. 什么是运算符重载 重载这个概念在早前的函数重载,大家已经见识过了。函数可以重载, 运算符也是可以重载。 运算符重载就是对已有的运算符重新进行定义,赋予其另一种功能,以达到适应不同的数据类型。运算符重载不能改变它本来的寓意(也就是 加法不能变更为 减法) 运算符重载只是一种 “语法上的方便” , 它只是一种函数调用的方式。 int a = 3 ; int b = 4 ; int c = a + b ; //编译器通过 Student s1 ; Student s2 ;
Visual Studio2017C++学习笔记（十七）-类和对象的继承
weixin_41957446的博客
08-12 726
主要介绍了继承的语法，继承方式以及继承中相关问题的解决的方法。
软件测试学习笔记丨Pytest配置文件
ceshiren_com的博客
08-27 1741
pytest.ini是pytest的配置文件；可以修改pytest的默认行为；不能使用任何中文符号，包括汉字、空格、引号、冒号等。
MySQL基础学习
最新发布
eugene03的博客
08-29 1279
事务是一组操作的集合，它是一个不可分割的工作单位，事务会把所有操作作为一个整体一起向系统提交或者撤掉操作请求，那么这些操作要么同时成功，要么同时失败。笛卡尔积：两个集合 A集合和B集合的所有组合情况（在多表查询时，需要消除无效的笛卡尔积）对于union 查询，就是把多次查询的结果合并起来，行程一个新的查询结果集。相当于查询表1（左表）的所有数据包含表1和表2交集部分的数据。相当于查询表2（右表）的所有数据包含表1和表2交集部分的数据。自连接查询，可以是内连接查询，也可以是外连接查询。
前端开发学习Docker记录02容器操作
第⑦个前端
08-29 760
使用docker ps 可以看到有哪些镜像在运行。
【AI学习】在魔塔社区玩Ollama：部署GLM4和CodeGeeX4
bylander的博客
08-27 936
尝试了一下CodeGeeX4-ALL-9B 的Ollama部署。GPU要明显快很多，CPU的速度，也还凑合吧
html+css+js网页设计 个人博客模版 我的学习经历7个页面
qq_42431718的博客
08-28 609
html+css+js网页设计 个人博客模版 我的学习经历7个页面 网页作品代码简单，可使用任意HTML编辑软件（如：Dreamweaver、HBuilder、Vscode 、Sublime 、Webstorm、Text 、Notepad++ 等任意html编辑软件进行运行及修改编辑等操作）。
C++学习笔记：派生类与面向对象程序设计
"这篇学习笔记主要讨论了C++中的派生类声明，以及C++的一些基本概念，包括其历史、特点和应用领域。" 在C++中，派生类是基于一个或多个基类创建的新类。这允许我们通过继承基类的特性来构建更复杂的类结构。例如，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值