黑马程序员c++ 继承

最新推荐文章于 2024-11-02 16:10:25 发布
最新推荐文章于 2024-11-02 16:10:25 发布
阅读量739 收藏 30
点赞数 27
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c_wsz3/article/details/138861795
版权

基本语法

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

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

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

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

例如下面的代码

#include <iostream>

using namespace std;

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

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

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

void test()
{
	cout << "Java学习视频如下" << endl;
	Java().header();
	Java().left();
	Java().footer();
	Java().content();
	
	cout << "--------------------------------" << endl;
	
	cout << "Python学习视频如下" << endl;
	Python().header();
	Python().left();
	Python().footer();
	Python().content();
	
	cout << "--------------------------------" << endl;
	
	cout << "CPP学习视频如下" << endl;
	CPP().header();
	CPP().left();
	CPP().footer();
	CPP().content();
}

int main()
{
	test();
	
	return 0;
}

我们发现Java、Python、CPP中除了自己独有的函数外都含有三个相同的函数

这时我们就可以使用继承的技术将类中重复的部分作为基类，减少代码量

#include <iostream>

using namespace std;

class Base
{
public:
	
	void header()
	{
		cout << "首页、公开课、登录、注册……（公共头部）" << endl;
	}
	
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图……（公共底部）" << endl;
	}
	
	void left()
	{
		cout << "Java、Python、CPP……（公共分类列表）" << endl;
	}
};

class Java : public Base
{
public:
	void content()
	{
		cout << "Java学习视频" << endl;
	}
}; 

class Python : public Base
{
public:
	void content()
	{
		cout << "Python学习视频" << endl;
	}
};

class CPP : public Base
{
public:
	void content()
	{
		cout << "CPP学习视频" << endl;
	}
};

void test()
{
	cout << "Java学习视频如下" << endl;
	Java().header();
	Java().left();
	Java().footer();
	Java().content();
	
	cout << "--------------------------------" << endl;
	
	cout << "Python学习视频如下" << endl;
	Python().header();
	Python().left();
	Python().footer();
	Python().content();
	
	cout << "--------------------------------" << endl;
	
	cout << "CPP学习视频如下" << endl;
	CPP().header();
	CPP().left();
	CPP().footer();
	CPP().content();
}

int main()
{
	test();
	
	return 0;
}

从上面的代码中我们可以看到

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

其中子类又称为 派生类

父类又称为 基类

继承方式

继承方式与权限类似 一共有三种：

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

        

从上表我们可以看到：

父类中私有权限的内容在子类中不管用什么继承方式都是不能被访问的，其余的权限内容的改变与不同的继承方式之间的关系如下表：

继承方式父类权限子类权限
公共继承公共权限，保护权限公共权限，保护权限
保护继承公共权限，保护权限保护权限
私有继承公共权限，保护权限私有权限
#include <iostream>

using namespace std;

class Base
{
public:
	
	int m_A = 10;
	
protected:
	
	int m_B = 10;
	
private:
	
	int m_C = 10;
};

class Son1 : public Base
{
public:
	
	void func()
	{
		m_A = 100;
		m_B = 100;
//		m_C = 100;
	}
};

class Son2 : protected Base
{
public:
	
	void func()
	{
		m_A = 100;
		m_B = 100;
//		m_C = 100;
	}
}; 

class Son3 : private Base
{
public:
	
	void func()
	{
		m_A = 100;
		m_B = 100;
//		m_C = 100;
	}
};

class GrandSon : public Son3
{
public:
	
	void func()
	{
//		m_A = 1000;
//		m_B = 1000;
	}
};

void test()
{
	cout << Son1().m_A << endl;
//	cout << Son1().m_B << endl;
	
//	cout << Son2().m_A << endl;
//	cout << Son2().m_B << endl;
}

int main()
{
	test();
	
	return 0;
}

继承中的对象模型与开发人员命令工具使用

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

我们通过代码来看看

#include <iostream>

class Base
{
public:
	int m_A;

protected:
	int m_B;

private:
	int m_C;
};

class Son : public Base
{
public:
	int m_D;
};

void test()
{
	std::cout << sizeof(Son) << std::endl;
}

int main()
{
	test();

	return 0;
}

代码运行结果为 16 说明父类中的所有成员均被子类继承，包括不能被访问的私有权限成员

我们也可以用vs的开发人员命令工具来查看Son类的成员结构

视频中演示的时2019版的，我的是2022版

首先在vs2022根目录搜索Developer Command Prompt

如果你的源文件不在C盘，开始我们需要跳转盘符，我的在D盘，输入D: 回车

跳转到D盘后在跳转到程序目录下，输入cd，空格输入程序目录 回车进入程序目录

输入dir查看当前目录的程序

 接下来输入cl /d1 reportSingleClassLayoutSon（报告单个类的布局 类名）ConsoleApplication4.cpp（程序名（可以输入名称部分后tap键补齐）） 回车

我们可以看到Son类继承Base之后类的结构 包含了Base中的所有成员

继承中构造和析构顺序

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

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

#include <iostream>

using namespace std;

class Base
{
public:
	Base()
	{
		cout << "父类构造函数调用" << endl; 
	}
	
	~Base()
	{
		cout << "父类析构函数调用" << endl;
	}
};

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

void test()
{
	Son();
}

int main()
{
	test();
	
	return 0;
}

 通过调用上面的代码，我们可以得到下面的结果：

可以看到，在类的继承中，父类的构造先于子类的构造，子类的析构先于父类的析构

 继承同名成员处理方式

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

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

using namespace std;

class Base
{
public:
	
	int m_A = 10;
};

class Son : public Base
{
public:
	
	int m_A = 100;
};

void test()
{
	Son s;
	
	cout << s.m_A << endl;
	cout << s.Base::m_A << endl;
}

int main()
{
	test();
	
	return 0;
}

在上面代码中，s.m_A会直接访问子类中的成员，而在对象的点元素符后加上父类作用域，就可以访问父类中的成员。

需要注意的是，如果子类中没有与父类同名的成员，s.m_A会直接访问父类中的成员。

如下面代码，调用test函数得到结果 10

class Base
{
public:
	
	int m_A = 10;
};

class Son : public Base
{
};

void test()
{
	Son s;
	
	cout << s.m_A << endl;
}

成员函数的调用与此相同 

#include <iostream>

using namespace std;

class Base
{
public:
	
	int m_A = 10;
	
	void func()
	{
		cout << "Base func 调用" << endl;
	}
};

class Son : public Base
{
public:
	
	int m_A = 100;
	
	void func()
	{
		cout << "Son func 调用" << endl;
	}
};

void test()
{
	Son s;
	
	cout << s.m_A << endl;
	cout << s.Base::m_A << endl;
	
	s.func();
	s.Base::func();
}

int main()
{
	test();
	
	return 0;
}

 调用结果如下：

 

需要注意的是：当子类中出现了与父类中同名的函数，父类中的所有同名函数都会被屏蔽，无法直接访问，也不能通过函数重载方式直接访问。

例如下面的代码：

#include <iostream>

using namespace std;

class Base
{
public:
	
	int m_A = 10;
	
	void func()
	{
		cout << "Base func 调用" << endl;
	}
	
	void func(int a)
	{
		cout << "Base func(int a) 调用" << endl;
	}
};

class Son : public Base
{
public:
	
	int m_A = 100;
	
	void func()
	{
		cout << "Son func 调用" << endl;
	}
};

void test()
{
	Son s;
	
	cout << s.m_A << endl;
	cout << s.Base::m_A << endl;
	
	s.func();
	s.Base::func();
	
//	s.func(10);	//无法通过函数重载直接调用父类中的同名函数
	s.Base::func(10); 
}

int main()
{
	test();
	
	return 0;
}

运行结果如下：

 总结：

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

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

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

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

  • 访问子类同名成员，直接访问
  • 访问父类同名成员，加作用域
#include <iostream>

using namespace std;

class Base
{
public:
	static int m_A;
	
	static void func()
	{
		cout << "Base func()函数调用" << endl;
	}
	
	static void func(int a)
	{
		cout << "Base func(int)函数调用" << endl;
	}
};

class Son : public Base
{
public:
	static int m_A;
	
	static void func()
	{
		cout << "Son func()函数调用" << endl;
	}
};

int Base::m_A = 10;
int Son::m_A = 100;

void test()
{
	Son s;
	cout << s.m_A << endl;
	cout << s.Base::m_A << endl;
	
	cout << Son::m_A << endl;
	cout << Son::Base::m_A << endl;
	
	s.func();
//	s.func(10); //父类中与子类同名的函数都不能直接访问，只能通过加作用域访问。
	s.Base::func(10);
	Son::func();
	Son::Base::func(); 
}

int main()
{
	test();
	return 0;
}

从上面的代码可以看到，静态成员变量与继承同名变量的处理相互之间没有冲突的地方。

需要注意的主要有以下几点：

  •  静态成员变量需要类内声明类外初始化
  • 静态成员变量可以通过对象进行访问也可以直接通过类名进行访问
  • 父类与子类出现同名成员时，子类直接访问，父类加作用域
  • 静态成员变量通过类名访问时，要先访问子类作用域在访问父类作用域

多继承语法

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

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

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

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

#include <iostream>

using namespace std;

class Base1
{
public:
	
	Base1()
	{
		m_A = 10;
	}
	
	int m_A;
};

class Base2
{
public:
	
	Base2()
	{
		m_A = 20;
	}
	
	int m_A;
};

class Son : public Base1, public Base2
{
public:
	
	Son()
	{
		m_C = 30;
		m_D = 40;
	}
	
	int m_C;
	int m_D;
};

void test()
{
	Son s;
	
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
}

int main()
{
	test();
	
	return 0;
}

在上面的代码中，Son的父类Base1和Base2有相同的成员变量m_A，再用Son访问时就要加上父类作用域加以区分。

菱形继承

菱形继承概念

  • 两个派生类继承同一个基类
  • 又有某个类同时继承两个派生类

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

菱形继承经典案例：

 菱形继承问题：

  1. 羊继承了动物的数据，驼继承了动物的数据，当羊驼使用数据时，就会产生二义性
  2. 羊驼继承了两份来自动物的数据，但其实这份数据我们只需要一份就可以
#include <iostream>

using namespace std;

class Animal
{
public:

	int m_Age;
};

class Sheep : public Animal{};

class Tuo : public Animal{};

class SheepTuo : public Sheep, public Tuo{};

void test()
{
	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;
}

int main()
{
	test();

	return 0;
}

例如在上面的代码中，Animal类中的m_Age变量被Sheep类和Tuo类继承，而SheepTuo类多继承了上面两类，使得SheepTuo类中有两个m_Age类

这时我们访问这个变量就要加其中一个父类的作用域，但实际上这个数据我们在羊驼类中只需要一份就可以，这时我们就需要在继承方式前加关键字virtual，

#include <iostream>

using namespace std;

class Animal
{
public:

	int m_Age;
};

class Sheep : virtual  public Animal{};

class Tuo : virtual public Animal{};

class SheepTuo : public Sheep, public Tuo{};

void test()
{
	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()
{
	test();

	return 0;
}

 这时称Animal类为虚基类，Sheep，Tuo类的继承方式为虚继承，

此时这四个类就共享一个m_Age变量，避免了空间的浪费

我们再通过开发人员命令工具看一下SheepTuo的类布局

可以看到Sheep原来的int类型变成了vbptr（virtual base pointer）虚基类指针， 指向下面的vbtable(virtual base table)虚基类表，这时通过SheepTuo访问成员变量时就会通过虚基类指针获得虚基类表中的偏移量，通过偏移量访问唯一的，Animal类中的m_Age成员变量。

c_wsz3
关注
黑马程序员C++核心编程
weixin_73900785的博客
12-25 1321
作用：函数名可以相同，提高复用性同一个作用域下函数名相同函数类型不同或个数不同或顺序不同函数的返回值不可以作为函数重载的条件​//函数重载满足条件：​//+同一个作用域下//+ 函数名相同//+ 函数 类型不同 或 个数不同 或 顺序不同 * *​//都是全局作用域，函数名相同，cout
黑马程序员——C++继承
weixin_44730078的博客
11-22 800
继承是为了减少重复代码，继承基本语法class　子类　：继承方式　父类　　　 子类和父类又分别叫做派生类和基类 class java :public base 继承方式由：公共继承、保护继承、私有继承 父类中的私有权限成员，子类中无法访问 #include <iostream> using namespace std; #include <string> //普通实现 //class java { //public: // void header() { // cout &
黑马程序员C++自学笔记
qq_66734705的博客
08-19 744
struct 结构体名 {结构体成员列表}；struct 结构体名 变量名struct 结构体名 变量名 = {成员1值，成员2值……}定义结构体时顺便创建变量定义结构体时的关键字是struct，不可省略创建结构体变量时，关键字struct可以省略结构体变量利用操作符"."访问成员作用：函数名可以相同，提高复用性同一个作用域下函数名相同函数参数的类型不同，或者个数不同，或者顺序不同注意：函数的返回值不可以作为函数重载的条件概述：多态是C++面向对象三大特征之一多态分为两类。
黑马程序员C++笔记
m0_62076827的博客
01-12 4278
黑马程序员C++笔记
哔哩哔哩黑马程序员C++课程个人学习笔记
weixin_53073284的博客
08-01 5454
此博文仅作为个人c++学习笔记记录，或有错误不建议参考！！！
《黑马程序员C++》核心编程部分
qq_44939870的博客
07-25 1328
用户提供了有参，编译器不会提供无参，但会提供拷贝；用户提供了拷贝，编译器什么构造函数都不会提供。深拷贝与浅拷贝深浅拷贝是面试的一个经典的问题，也是常见的一个坑。
黑马程序员C++提高编程
weixin_73900785的博客
12-25 1055
示例：//Vector中存放自定义数据类型public:int m_Age;//存放对象//向容器中添加数据//遍历容器中的数据it!= v.end();it++) {cout << "姓名：" << (*it).m_Name << " 年龄：" << (*it).m_Age << endl;//it 是一个指针,解引用(*it)解出来的数据类型就是尖括号里的，即Person类型 需要拿他的属性出来，用“.”
C++黑马程序员教程-学习笔记二_黑马程序员c++web项目
2301_79054215的博客
04-28 637
/类中的属性和行为，统一称为成员//属性，又称为成员属性、成员变量public: //共用权限int id;//行为，又称为成员函数、成员方法name = nn;id = ii;ss.set_student("张三", 1);
【C++】黑马程序员 C++学习课程—C++核心编程
weixin_51154380的博客
11-14 1202
*作用：**函数名可以相同，提高复用性同一个作用域下函数名称相同函数参数类型不同或者个数不同或者顺序不同函数的返回值不可以作为函数重载的条件//函数重载需要函数都在同一个作用域下{cout
C++黑马程序员学习资料
08-05
C++黑马程序员学习资料，附赠《InterviewGuide第四版By阿秀》、《LeetCode刷题手册》、《背包问题九讲》、《算法图解》pdf版本，三个基础课程文档手册及三个实验项目，由简到繁分别为《通讯录管理系统》、《职工管理...
黑马程序员匠心之作 C++教程_第5阶段-C++提高编程资料讲义.rar
03-19
《黑马程序员匠心之作 C++教程_第5阶段-C++提高编程资料讲义》是一份针对C++编程初学者精心制作的教程资料，旨在帮助学习者深入理解和提升C++编程技能。这份讲义涵盖了许多关键的C++知识点，下面将对其进行详细解读...
黑马程序员C++教程讲义-保真
05-07
黑马程序员的C++教程讲义会系统地介绍这些概念，帮助初学者从0到1逐步掌握C++编程。"assets"目录可能包含相关的辅助材料，如示例代码、图片或课件，这些资源可以增强学习体验，使理论与实践相结合。
黑马程序员匠心之作 C++教程_第7阶段-C++实战项目机房预约讲义.rar
03-19
《黑马程序员匠心之作 C++教程_第7阶段-C++实战项目机房预约讲义》是为C++初学者量身定制的一份详细教学资源。这份讲义深入浅出地介绍了C++编程语言，并通过实际的机房预约系统项目，帮助学习者将理论知识与实践相...
Type-C PD诱骗取电快充协议芯片 支持PD 5V、9V、12V、15V、20V电压
最新发布
xcx003的博客
11-02 443
XSP01A是一款专为Type-C接口设计的取电诱骗协议芯片，它它集成了先进的电源管理和协议控制功能，旨在为用户提供高效、安全、稳定的充电体验。该芯片集成USB Power Delivery (PD) 3.0/2.0快充协议，支持从手机充电器/车充等电源上取电给产品供电。支持最大功率100W给设备安全快速供电。综上所述，XSP01A诱骗取电协议芯片以其高效、安全、稳定的充电性能以及广泛的设备兼容性和应用场景，正在逐步改变着我们的充电体验和设备电源管理方式。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 181
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 869
书生浦语大模型实战营第四期：Linux前置基础
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 28
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2195
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
黑马程序员c++核心编程
10-24
黑马程序员C++核心编程是一门针对C++语言的深入学习课程，主要包括C++基础语法、面向对象编程、模板、STL等内容。该课程通过理论讲解和实战演练相结合的方式，帮助学员深入理解C++语言的核心概念和编程思想，掌握C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值