C++继承(图文非常详细)

C++之继承 继承的概念及定义 继承的概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加功能,这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构,体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用,继承是类设计层次的复用。 这就比如我们设计一个学生管理系统,学校中有老师,学生,工作人员等,我们要记录他们的信息比如学生有电话,姓名,地址,学号等这些信息。 class Student { str 阅读详情

继承的概念

1.什么是继承

1.简单定义

我们来看一下下面这串代码注意其中的两个类father 和 son

using namespace std;
#include<iostream>
class father
{
public:
	void definity()
	{
		cout << "father" << endl;
	}
protected:
	int tall = 180;
	int age = 20;
};
class son : public father
{
public:
	void definityson()
	{
		cout << "son" << endl;
		cout << tall << endl;
	}
protected:
	int tall1 = 200;
	int age1 = 25;
};
int main()
{
	son SN;
	SN.definity();
	SN.definityson();

}

 我们可以发现son类定义的SN可以调用father的函数definity()

 

如上图所示,这便是继承的格式。

 class 类名: 继承方式  继承的类名

 通过这样继承的方式我们可以想想一下,就是将father里面的内容全部让son可见,如果你觉得不好理解,你可以认为就是father里面的内容全部加进son里面,所以son就可以访问father里面的内容。

 

 注释的内容就是son从father那里继承过来的内容,只是没有显示出来,但同样可以使用

 2.使用场景

当我需要定义两个类时,但恰好这两个类的内容有大部分是相同的。

class teacher
{
public:
	void teach()
	{
		cout << "I respond to teach" << endl;
	}
	void approach()
	{
		cout << " I can admitted" << endl;
	}
protected:
	int tall;
	int age;
	int rank;
};
class student
{
public:
	void study()
	{
		cout << "I respond to teach" << endl;
	}
	void approach()
	{
		cout << " I can admitted" << endl;
	}
protected:
	int tall;
	int age;
	int rank;
};

我们看以上代码有两个类,但这两个类里面的内容大部分是相同的,如果我们还要定义其它的类,也和这两个类大部分的内容是相同的,那么一个一个定义是不是有点太麻烦了。

那么这时候我们只需将相同的部分全部放入一个类A里面,其它的类只要定义自己特殊的那部分,然后再继承类A,那么就完成了我们需要的定义

代码如下

class person
{
public:
	void approach()
	{
		cout << " I can admitted" << endl;
	}
protected:
	int tall;
	int age;
	int rank;
};
class teacher:public person
{
public:
	void teach()
	{
		cout << "I respond to teach" << endl;
		cout << rank << endl;
	}
	void prove()
	{
		rank = 20;
	}
};
class student:public person
{
public:
	void study()
	{
		cout << "I respond to teach" << endl;
		cout << rank << endl;
	}
	void error()
	{
		rank = 10;
	}
};
int main()
{
	student xiaoming;
	teacher laoxu;
	laoxu.prove();
	xiaoming.error();
	laoxu.teach();
}

 3.继承规则

我们来看这一段,当我们用public的方式继承person的时候,变量DNA是不能访问的,但rank可以访问,因为DNA再person的private范围里

 2.特殊的继承方式

1.类模板继承

template<class T>
class Stack : public vector<T>
{
public:
	void PUSH(const T& x)
	{
		vector<T>::push_back(x);
	}
	void pop()
	{
		vector<T>::pop_back();
	}
	T& top()
	{
		return vector<T>::back();
	}
	bool empty()
	{
		return vector<T>::empty();
	}
};
int main()
{
	Stack<int> s1;
	s1.PUSH(1);
	s1.PUSH(2);
	s1.PUSH(3);
	s1.PUSH(4);
	s1.PUSH(5);
	s1.PUSH(6);
	s1.pop();
	cout << s1.top() << endl;
	cout << s1.empty() << endl;
}

上述代码中Stack直接继承了库函数中的vector,并且提供了模板参数,这样就大大方便了我们去模拟实现Stack 

2.基类和派生类之间的转换 

public继承的派生类对象可以赋值给基类的指针,形象地说就是,派生类将基类多出来的那部分切割掉,然后再赋值给基类的指针和引用

 

 如下图代码

class person
{
public:
	void study()
	{
		cout << " I can studying " << endl;
	}
	void teach()
	{
		cout << "I can teaching" << endl;
	}
	string name;
	int age;
	int sex;
};
class student:public person
{
public:
	int NO;
};
int main()
{
	student s1;
	s1.age = 10;
	person* p2;
	p2 = &s1;
	cout << p2->age << endl;
}

可以通过基类的指针访问派生类的成员 

基类不能赋值给派生类 

 3.隐藏规则

当派生类中有和基类一样的函数,那么派生类便会隐藏基类的函数

class person
{
public:
	void study()
	{
		cout << " I can studying " << endl;
	}
	void teach()
	{
		cout << "I can teaching" << endl;
	}
};
class student:public person
{
public:
	void study()
	{
		cout << " He can not to studying" << endl;
	}
};
int main()
{
	student s1;
	s1.study();
}

我们可以看到,当我们调用study函数时,并没有调用基类的study函数,而是调用了派生类的study函数,因为派生类中有和基类同名的函数,所以派生类便隐藏了基类的函数 

当我们需要调用基类的函数时我们需要特殊声明比如 

 

声明格式 基类名称 :函数 

函数隐藏只要是同名便会隐藏,所以不存在所谓重载 

 

并不建议将派生类函数和基类函数用作同一名字 

3.四种派生类的默认成员函数

1.默认构造函数

当我们调用派生类的默认构造函数时,同时也会调用基类的默认构造函数

class person
{
public:
	person(const char* ch = "xiaoming")
	{
		name = ch;
		cout << "until to person" << endl;
	}

protected:
	const char* name;
};
class student:public person
{
public:
	student()
	{
		cout << "until to student" << endl;
		tall = 100;
		age = 10;
	}

protected:
	int tall;
	int age;
};
int main()
{
	student s1;
}

我们看如上代码 和 结果

当我实例化派生类对象时,同时也会调用基类的默认构造函数,那是因为要用基类的默认构造函数去初始化基类对象。

 2.析构函数

class person
{
public:
	person(const char* ch = "xiaoming")
	{
		name = ch;
		cout << "until to person" << endl;
	}

	~person()
	{
		cout << " until to ~person" << endl;
	}
protected:
	const char* name;
};
class student:public person
{
public:
	student()
	{
		cout << "until to student" << endl;
		tall = 100;
		age = 10;
	}
	~student()
	{
		cout << "until to ~student" << endl;
	}
protected:
	int tall;
	int age;
};
int main()
{
	student s1;
}

如上图所示,当我调用派生类对象的析构函数时,我们会先调用派生类对象的析构函数,再调用基类的析构函数,这和默认构造函数的顺序有所不同,我们先初始化基类再初始化派生类,先析构派生类再析构基类 

 3.拷贝构造函数

class person
{
public:
	person(const char* ch = "xiaoming")
	{
		name = ch;
		cout << "until to person" << endl;
	}
	person(const person& ps)
	{
		name = ps.name;
	}

	~person()
	{
		cout << " until to ~person" << endl;
	}
protected:
	const char* name;
};
class student:public person
{
public:
	student()
	{
		cout << "until to student" << endl;

		tall = 100;
		age = 10;
	}
	student(const student& st)
	{
		tall = st.tall;
		age = st.age;
	}
	~student()
	{
		cout << "until to ~student" << endl;
	}
	void inital()
	{
		tall = 180;
		age = 20;
		name = "xiaozhang";
	}
protected:
	int tall;
	int age;
};
int main()
{
	student s1;
	s1.inital();
	student s2(s1);
}

如上述代码,我们将s1的数据更改,再用s1的数据去拷贝s2,那么s1和s2的结果会是怎么样呢 

 我们发现s1和s2位于基类中的成员变量不同,这是因为当调用拷贝构造时,并没有调用到基类的拷贝构造,所以导致基类成员的数据没有拷贝进去

我们需要在初始化列表里调用基类的拷贝构造函数

 

在派生类的拷贝构造 初始化列表中调用基类的拷贝构造

 4.重载赋值运算符

class person
{
public:
	person(const char* ch = "xiaoming")
	{
		name = ch;
		cout << "until to person" << endl;
	}
	person(const person& ps)
	{
		cout << "COPY until to person" << endl;
		name = ps.name;
	}
	person& operator=(const person& st1)
	{
		cout << "= person until to =" << endl;
		if (this != &st1)
		{
			name = st1.name;
		}
		return *this;
	}
	~person()
	{
		cout << " until to ~person" << endl;
	}
protected:
	const char* name;
};
class student:public person
{
public:
	student()
	{
		cout << "until to student" << endl;

		tall = 100;
		age = 10;
	}
	student(const student& st):person(st)
	{
		cout << "COPY until to student" << endl;
		tall = st.tall;
		age = st.age;
	}
	~student()
	{
		cout << "until to ~student" << endl;
	}
	student& operator=(const student& st1)
	{
		cout << "= person until to =" << endl;
		if (this!=&st1)
		{
			person::operator=(st1);
			tall = st1.tall;
			age = st1.age;
		}
		return *this;
	}
	void inital()
	{
		tall = 180;
		age = 20;
		name = "xiaozhang";
	}
protected:
	int tall;
	int age;
};
int main()
{
	student s1;
	s1.inital();
	student s2;
	s2 = s1;
}

通过实现这最后一个函数我们可以看看成员函数的调用规则 

 

首先构造两个派生类,分别调用两次基类构造和派生类构造

然后赋值再调用两次赋值函数

析构先析构派生类再析构基类 

4.不能被继承的类

第一种

第一种在基类定义时 名称后面加final 

当我们定义基类时,在后面加final ,那么派生类在继承时就失败了 

第二种 

第二种,将默认构造函数放在private范围内 

 

当我们将基类的默认构造函数放在private里时,派生类在构造对象时会调用基类的默认构造函数,但是因为基类的默认构造函数是存在于private内的,所以会调用失败 

5.继承与友元 

友元关系不能继承,也就是说基类友元不能访问派生类私有和保护成员 

using namespace std;
#include<iostream>
class person
{
	friend void print();
public:
	person()
	{
		cout << "I am a person" << endl;
	}
private:
	int gender=0;
	int tall=0;
};
class student :public person
{
public:
	student()
	{
		cout << "I am a student" << endl;
	}
private:
	int grade=0;
};
void print()
{
	person p1;
	p1.gender = 10;
	cout << p1.gender << endl;
	//print()是基类的友元函数,所以可以访问基类构成的对象private成员
	student s1;
	s1.grade = 10;
	cout << s1.grade << endl;
	//虽然student继承了person,但友元关系不能继承,所以print()不能访问派生类的private成员
}
int main()
{
	print();
}

 6.继承与静态成员

基类定义了一个static成员,则整个继承过程中,只会产生一个static,不管继承多少次,都只会有这一个static成员。

using namespace std;
#include<iostream>
class person
{
public:
	static int st;
private:
	int gender=0;
	int tall=0;
};
int person::st = 50;
//类中的静态变量要在类外初始化
class student :public person
{
public:
private:
	int grade=0;
};
int main()
{
	student s1;
	person p1;
	cout << p1.st << endl;//输出50
	cout << s1.st << endl;//输出50
	//不管继承多少次它们的st都是同一个st,因为st存储在静态区中
}

 7.继承模型

1.单继承

 上述类似单继承模型一个基类只被一个派生类继承一次,并且每个派生类都只被一个派生类继承一次

2.多继承 

以上就是多继承模型指的是一个基类或一个派生类被两个或两个以上的派生类所继承 

3.菱形继承 

以上就是菱形继承的模型,指的就是一个派生类对另一个派生类或者基类继承了两次或两次以上 

但是这样的话就会有双份数据,所以会使对象在调用的时候不明确调用那个 

using namespace std;
#include<iostream>
class person
{
public:
	int gender=0;
	int tall=0;
};
class student :public person
{
public:
private:
	int grade=0;
};
class classmate :public person
{
public:
private:
	int next;
};
class myself : public classmate, public student
{
public:
private:
	int myself;
};
int main()
{
	myself MY;
	cout << MY.gender << endl;//调用gender失败,编译器不知道该调用哪个gender
	cout << MY.classmate::gender << endl;//调用成功我们需要指出该调用的类范围
}

C++为了解决这样的问题,发明了虚继承 

4.虚继承 

 

当有一个基类被继承两次时我们需要在第一次被继承时加上virtual进行虚继承 

比如 

通过增加virtual来对person进行虚继承,那么这样myself继承时就只会继承一份person 

但是并不建议设计菱形模型,因为这样会复杂非常多 

 5.多继承指针偏移问题

using namespace std;
#include<iostream>
class student
{
public:
private:
	int grade=0;
};
class classmate
{
public:
private:
	int next=0;
};
class myself : public classmate, public student
{
public:
private:
	int myself;
};
int main()
{
	myself MY;
	classmate* p1 = &MY;
	myself* p2 = &MY;
	student* p3 = &MY;
	cout <<" classmate : " << p1 << endl;
	cout <<" myself    : " << p2 << endl;
	cout <<" student   : " << p3 << endl;

}

我们来看上述代码 

myself先是继承了classmate,然后再继承了student那么myself的顺序空间如下 

 

classmate在前student在后 

当我们使用myself类型指针和classmate类型指针和student类型指针指向这个myself对象时指针位置如图所示 

所以classmate和myself在同一位置而student在它们后面。所以代码运行结果如下 

 

 8.继承和组合

1.组合的概念

继承我们已经讲过了,那我们来讲讲组合的方式

 

这便是组合的方式,我们直接在一个类里面构建另外一个类的对象,我们可以使用这个对象的函数。  

2.组合和继承的优缺点 

组合将被组合的内部结构封闭了起来,使我们自己构建的类不能访问它的private和protected,安全性比较高,但继承不一样,继承可以访问,所以安全性比较低,我们能使用组合时尽量使用组合。

【NVIDIA Jetson Orin系列 - 安装NVIDIA SDK Manager】 NVIDIA Jetson Orin - 安装NVIDIA SDK Manager 阅读详情

相关推荐

到底什么是电源的斜波补偿,电源芯片CS引脚作用,一文讲清楚!

上文有提到电流环,其实电流环再细分也有很多模式,用的最多的是峰值电流模式峰值电流模式调节工作原理如下:(1)当输出负载增大时,输出电压降低,因此,Vc 增大,线性增加的电感电流只有升高到更大的值才能使 PWM 电流比较器翻转,开关管导通的时间增长,占空比增加,输入功率增加,因此输出电压增加,当输出电压增加到调节的范围内时,系统保持平衡。

jwgdhuwdhg的博客 1万+

c++:继承(超详解)

目录一:什么是继承二:继承的格式继承的总结:二:子类和父类(基类和派生类)1.子类和父类的相互赋值:2.同名的成员变量3.同名成员函数三:子类中默认的成员函数1.构造函数2.析构函数3.拷贝构造4.赋值运算符重载 四:单继承和多继承单继承: 多继承:菱形继承解决方法一:解决方法二:单继承和多继承的总结:定义:继承(inheritance)机制是面向对象程序设计中使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加功能。这样产生的新类,称派生类(或子类),被继承的类称基类(或父类)

qq_62718027的博客 8万+

新手别怕!用‘东北天’和‘右前上’坐标系,5分钟搞懂惯性导航姿态矩阵(含Python验证代码)

本文通过‘东北天(ENU)’和‘右前上(RFU)’坐标系,详细解析惯性导航中的姿态矩阵概念。包含Python代码验证,帮助新手快速理解坐标变换、欧拉角及旋转矩阵的构建与应用,特别强调有限转动不可交换性与无限转动次序无关的区别。

weixin_29062255的博客 333

c++ 类的继承

一、类的基本概念 c++最重要的特征是代码重用,通过继承机制可以利用已有的数据类型来定义新的数据类型,新的类不仅拥有旧类的成员,还拥有新定义的成员。 一个 B 类继承于A类,或称从类 A 派生类 B。这样的话,类 A 成为基类(父类), 类B成为派生 类(子类)。 派生类中的成员,包含两大部分: 一类是从基类继承过来的,一类是自己增加的成员。 从基类继承过过来的表现其共性,而新增的成员体现了其个性。 继承的优点:减少代码的冗余 提高代码的重用性 二、继承的格式 派生类定义格式: Class 派生类

tranquilllll的博客 8989

奥顺居PHP测算引流SEO程序_八字风水_起名解梦_星座生肖综合门户源码

奥顺居PHP测算引流SEO程序_八字风水_起名解梦_星座生肖综合门户源码 S30新框架适合多种奥顺插件。

xl1407的博客 1757

医疗AI知识库更新慢?提示工程架构师用Agentic AI自动更新的策略

我们的目标是用Agentic AI替代传统更新流程中的“重复劳动”,让医疗知识库(以知识图谱为例)能自动跟踪最新医学进展,把“更新周期从数月缩短到数天”。从PubMed/指南数据库自动抓取新文献;用提示工程从文本中提取结构化医学知识;自动校验新知识与旧知识的冲突;将通过校验的知识写入知识图谱。拆问题:先讲医疗知识库更新慢的3大根源;给方案:用Agentic AI设计4个“小助手”解决问题;讲原理:每个小助手的工作逻辑+提示工程技巧;做实战。

AI 原生应用开发的博客 1063

C++类的继承

C++中类的继承 一、继承基本概念 继承是一个进程,通过继承,一个对象可以获得另一个对象的属性(包括函数),并可向其中加入属于自己的一些特征。作为C++语言的一种重要机制,用继承的方法可以自动为一个类提供来自另一个类的操作和数据结构,进而使程序设计人员在一个一般的类的基础上很快建立一个新的类,而不必从零开始设计每个类。 当一个类被其他的类继承时,被继承的类称为基类,又称为父类。 继承其他类属性的类称为派生类,又称为子类。 一般情况下,继承的进程起源于一个基类的定义,基类定义了其所有派生类的公有属性。从本质上

XiaoZ的博客 2056

【知识图谱】实践篇——基于知识图谱的《红楼梦》人物关系可视化及问答系统实践:part1项目介绍与环境准备

看到这篇文章的你,相信对知识图谱相关概念不在陌生。知识图谱相关内容在实际开发中包含两个部分:1.知识图谱构建,2.知识图谱使用。知识图谱构建过程中涉及内容、技术都比较多。知识图谱的应用也逐渐在我们的生活中随处可见,其中基于知识图谱的问答系统就是其中的一个应用。基于知识图谱的问答系统称做KGQA(knowledge graph question answer),也有人称其为KBQA(knowledge based question answ).基于知识图谱的问答系统通常是使用的是领域知识图谱。下面就结合Git

让算法融入生活,改变生活! 4721

【C++】继承

目录 1. 概念 2. 定义 2.1. 使用格式 2.2. 继承方式与限定修饰符 3. 基类和派生类对象赋值转换 (public继承) 4. 继承中的作用域 5. 子类类的默认成员函数 6. 继承与友元 7. 静态成员 8. 菱形继承和虚继承 8.1 菱形继承 8.2 虚继承(virtual) 8.3 虚继承解决数据冗余和二义性的原理 9. 继承总结、继承与组合 9.1总结 9.2 继承与组合 1. 概念 继承(inheritance)机制是面向对象程序设..

Edward_Asia的博客 9563

MATLAB - Gazebo 联合仿真 —— 使用 UR10 机械臂检测和采摘水果

本示例演示如何在 Gazebo 物理模拟器中设置 Universal Robotics UR10 机械臂和仿真环境。您需要配置一个机器人从树上摘苹果的仿真环境。本示例演示如何利用这些工具箱,使用 Universal Robotics UR10 机械手模拟机器人检测并从树上摘取苹果。Robotics System Toolbox™ - 在 Simulink® 和 Gazebo 中对机械手进行建模、规划和模拟。Navigation Toolbox™ - 生成三维环境的占用图。

机器人控制与仿真应用 4186

Vue3 - 详细实现流程图编辑器可视化平台示例代码,打造前端web网页流程图在线编辑绘制操作展示,vue3自定义绘制流程图在页面上画流程图功能(提供各种操作按钮及节点控件,界面美观交互式流程图插件)

vue3,绘制流程图,在线流程图制作,在vue3中实现流程图,vue3做一个制作流程图的功能,vue3流程图组件,vue3流程图,流程图绘制展示,vue3流程图可视化在线编辑源码,基于VUE3的在线绘制流程图工具,vue3+logicflow流程图,绘制动态流程图并自定义节点和线,vue使用logicFlow绘制流程图,生成各种流程图图形可连接点移除,基于Vue的流程图组件,工作流程图,流程编辑器,vue3流程组件,vue-flow绘制流程图,绘制流程图示例demo,vue3 logicflow流程图使用教

🏆 前端领域优质创作者 9971

C++继承中通过VS开发人员命令提示符查看.cpp脚本中某个类的结构情况方法(详细图文教程)

C++继承中通过VS开发人员命令提示符查看.cpp脚本中某个类的结构情况

qq_40280673的博客 1161

20 Embedding 与向量检索:语义为什么能变成距离

Embedding 是 RAG 语义检索的数学基础。本文用工程视角讲清文本如何变成向量,为什么语义相近会表现为距离相近,Top-K 检索如何工作,以及在模型选择、同模型约束、精确匹配和召回评估上的常见坑。

老于的笔记的专栏 6204

C++菱形继承中的那些事【超详细 图文+代码】

前言 一、什么是多继承 二、菱形继承 1.引入虚基类 2.引入虚基表 总结 前言 我们上一篇说了世间万物都有一个继承体制,或多或少子类继承了父类的某些特征,但大多都是单向继承,但是就有些特例他就是多继承,比如: 我们从图片中就可以看到,两栖动物它既继承了水生动物的一部分特性,也继承了陆地动物的一些特性,那么我们的代码,会不会也会有这种多继承现象呢,我们一起来看一下。 提示:以下是本篇文章正文内容,下面案例可供参考 一、什么是多继承? 1.单继承 我们来看...

qq_45615577的博客 6361

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

C++ 虚函数表解析

C++ 虚函数表解析 陈皓 http://blog.youkuaiyun.com/haoel 前言 C++中的虚函数的作用主要是实现了多态的机制。关于多态,简而言之就是用父类型别的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数。这样的技术能够让父类的指针有“多种形态”,这是一种泛型技术。所谓泛型技术,说白了就是试图使用不变的代码来实现可变的算法。比方:模板技...

weixin_30567471的博客 59

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

【C++】 学习继承这一篇就够啦!【图文+代码】

一篇带你了解继承。 C++继承 前言 一、继承的概念 1.继承定义 2.继承关系和访问限定符 3.基类和派生类对象赋值转换 4.继承中的作用域 5.派生类的默认成员函数 6.继承与友元 7.继承与静态成员 总结 前言 世间万物都会有一个继承体制,他就或多或少会继承父类的某些特征,比如人,动物,等等,那么我们的代码会不会也有这一特征呢,让我们一起来看看把 提示:以下是本篇文章正文内容。 一、继承 继承(inheritance)机制是面向对...

qq_45615577的博客 4181

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

C++ 多态(超详细,图文并茂)

本文内容包括多态的概念(通过例子进行理解)、多态的定义和实现包括形成多态的两个必要条件和虚函数的概念、虚函数的重写的详细介绍、抽象类的概念、多态原理的分析,以及单继承表和多继承表的原理 。文章附代码图题解,非常详细。

2302_80475369的博客 7657

图文例解C++类的多重继承与虚拟继承

图文例解C++类的多重继承与虚拟继承图文例解C++类的多重继承与虚拟继承 文章导读:C++允许为一个派生类指定多个基类,这样的继承结构被称做多重继承。   在过去的学习中,我们始终接触的单个类的继承,但是在现实生活中,一些新事物往往会拥有两个或者两个以上事物的属性,为了解决这个问题,C++引入了多重继承的概念,C++允许为一个派生类指定多个基类,这样的继承结构被称做多重...

aolan7349的博客 134

C++ 多态 最详细图文+代码讲解

虚函数的重写(覆盖):派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同【三同】),则称子类的虚函数重写了基类的虚函数。这与普通函数的重载不同,函数的重载是需要参数的不同,且在同一作用域,而重写是针对虚函数的。那么总结下来,虚函数要完成重写需要满足以下条件1.这个函数得在基类和派生类中是虚函数(在派生类中可以省略掉virtural关键字,可以理解为是从基类继承下来的,但是推荐写上)。

fengjunziya的博客 494
上一篇: C++vector(详解)
下一篇: C++多态的使用
Arcane Code
博客等级 码龄3年 598粉丝 101原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值