继承/虚函数/多态/虚析构———（学习笔记）

已于 2024-03-10 12:43:18 修改
阅读量1.4k 收藏 36
点赞数 47
文章标签： 学习 笔记 c++
于 2024-03-01 16:59:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao_yi666/article/details/136378127
版权

正片开始

继承

掌握要点：

  1. 继承的写法

    1. 单继承：class 类名 ：权限 父类名{};
    2. 多继承：class 类名 ：权限 父类1名，权限 父类2名，父类3名…{}；

  2. 子类通过什么样的权限继承

    1. 以public权限继承：则父类中public下所有内容，会在子类中public下有一份，同理父类中protected下的所有内容会在子类中protected下有一份。
      public权限继承的特点：(在父类中是什么权限，在子类中就以相同的权限继承)
    2. 以protected权限继承：则父类中public下所有内容，会在子类中protected下有一份，父类中protected下的所有内容会在子类中protected下有一份。
      protected权限继承的特点：(将父类中的public下的所有内容继承到子类的protected下)
    3. 以private权限继承：则父类中public和protected下所有内容，会在子类中private下有一份。
      private权限继承的特点：(将父类中的public和protected下所有内容继承到子类的private下)

  3. 构造函数：

    1. 子类在创建对象时会优先调用父类的构造函数，再调用子类构造函数。
    2. 要先子类创建无参对象，父类中的构造函数必须存在无参的调用形态。

注意点：无论子类是用什么权限继承的，父类中的私有属性在子类中是无法访问的，并且子类创建对象也无法访问父类中的私有熟悉，父类中的私有属性只有在父类中才能访问。

单继承的实现
代码展示 
#include<iostream>
#include<string>
using namespace std;

class A
{
public:
	int age;
protected:
	int money;
	string name;
};

class B:public A
{
public:
	B(int age, int money, string name,int num)
	{
		//因为B继承了A,A的数据会在B中有一份可以这种方式初始化A的数据
		this->age = age;
		this->money = money;
		this->name = name;
		//初始化B的数据
		this->num = num;
	}
	void print()
	{
		cout << "age = " << age << endl;
		cout << "money = " << money << endl;
		cout << "name = " << name << endl;
		cout << "num = " << num << endl;
	}
public:
	int num;
};

int main()
{

	B b(18, 1000, "蟑螂", 1014);
	b.print();

	return 0;
}

输出结果
age = 18
money = 1000
name = 刘亦辰
num = 1014
多继承的实现
#include<iostream>
#include<string>
using namespace std;

class A
{
public:
	int age;
protected:
	int money;
	string name;
};

class A1
{
public:
	int A1_age;
protected:
	int A1_money;
	string A1_name;
};

class B:public A,public A1
{
public:
	B(int age, int money, string name, int A1_age, int A1_money, string A1_name, int num)
	{
		//因为B继承了A,A的数据会在B中有一份可以这种方式初始化A的数据
		this->age = age;
		this->money = money;
		this->name = name;
		//因为B继承了A1,A1的数据会在B中有一份可以这种方式初始化A1的数据
		this->A1_age = A1_age;
		this->A1_money = A1_money;
		this->A1_name = A1_name;
		//初始化B的数据
		this->num = num;
	}
	void print()
	{
		cout << "这是A的数据" << endl;
		cout << "age = " << age << endl;
		cout << "money = " << money << endl;
		cout << "name = " << name << endl<<endl;
		cout << "这是B的数据" << endl;
		cout << "num = " << num << endl<<endl;
		cout << "这是A1的数据" << endl;
		cout << "A1_age = " << age << endl;
		cout << "money = " << money << endl;
		cout << "name = " << name << endl;
	}
public:
	int num;
};

int main()
{
	B b(18,1000,"小丑",20,20000,"小帅",1014);
	b.print();
	return 0;
}
多继承中构造和析构的顺序问题
#include<iostream>
#include<string>
using namespace std;

class A
{
public:
	A()
	{
		cout << "A" << endl;
	}
	~A()
	{
		cout << "A" << endl;
	}
};

class B
{
public:
	B()
	{
		cout << "B" << endl;
	}
	~B()
	{
		cout << "B" << endl;
	}
};

class C
{
public:
	C()
	{
		cout << "C" << endl;
	}
	~C()
	{
		cout << "C" << endl;
	}

};

class D:public A,public B, public C
{
public:
	D()
	{
		cout << "D" << endl;
	}
	~D()
	{
		cout << "D" << endl;
	}
};

int main()
{
	D d;  //输出结果 A B C D D C B A
	return 0;
}

在多太继承中，常考点，那就是调用构造函数和析构函数的顺序问题，在我们创建子类对象的时候，会优先调用父类的构造函数，再调用自身的构造函数，那么当父类比较多的时候，是按照什么顺序来调用各个父类的构造函数的呢？我们来看看子类继承的写法 class D:public A,public B, public C{};其实调用顺序与我么们创建子类时写的父类顺序有关，从左自右依次调用父类的构造函数，当构造函数调用完了后就是析构函数了，析构函数调用顺序与构造函数相反，所以我们看见上面输出的结果是:构造函数->A B C D,析构函数->D C B A

虚继承
在多继承中，难免会碰到如下情况，A类中有数据a，B类和C类是A的继承类，此时a自然也会在B类和C类中有一份，然后D类又是C类和B类的继承类， D类自然有一份a，那么这份a是来自C类中的还是B类中的呢，就不得而知了，为了解决此类事件，产生了我们现在所说的虚继承

在这里插入图片描述

虚继承听着很抽象，到底什么是虚继承呢？在C类和B类中在父类前面加上修饰词virtual 此时C类和B类就成了虚继承了，是不是听起来很简单，我也这么觉得，在D类的初始化参数列表中需要初始化A类，此时数据a就来自A类，而不是来自B,C类了，然后此问题就完美解决了。

我们来看看代码

#include<iostream>
#include<string>
using namespace std;

class A
{
public:
	A(int a):a(a){}
	int a;
};
//虚继承
class B:virtual public A
{
public:
	B(int a,int b):A(a),b(b){}
	int b;
};
//虚继承
class C :virtual public A
{
public:
	C(int a, int c) :A(a), c(c) {}
	int c;
};

class D :public B, public C
{
public:
	D():B(1,1),C(2,2),A(3){} //这位置必须要调用A类
	void print()
	{
		//只有a来自A类，b和c来自B类和C类
		cout << "a = " <<a  << endl;
		cout << "b = " << b << endl;
		cout << "c = " << c << endl;
	}
};

int main()
{
	D d;
	d.print();
	return 0;
}

虚函数和纯虚函数和抽象类的介绍

1.虚函数

小知识点：

  1. 一个空类所占内存大小为1个字节
  2. 当一个类中只有虚函数时，无论存在多少个虚函数，此类所站内存大小都只与你在多少位平台下有关（列如：你在64位平台下，此时这个类所占内存大小就是8个字节；在32位平台下，这个内就占4个字节）
  3. 当一个类中有虚函数时，用这个类无论创建多少个对象，这些对象的内存中都用的是一份二级指针

问：你应该很好奇在一个类中只有虚函数存在的情况下为啥这个类所占大小会与多少位平台挂钩吧？
解：因为这个类的内存中存放着二级指针，这个二级指针又存放着一级指针的地址，一级指针存放着函数的地址

内存

在这里插入图片描述

虚函数的写法：在函数前面加上virtual关键字，此函数就是虚函数。

验证虚类是否真的存在二级指针，一级指针是否存在函数的地址

//x64平台下，地址8个字节
#include<iostream>
#include<string>
using namespace std;

class A
{
public:
	
	virtual void print1()
	{
		cout << "我是虚函数1" << endl;
	}
	virtual void print2()
	{
		cout << "我是虚函数2" << endl;
	}
};


int main()
{
	A a;
	//需要将a对象的地址转换成long long**是因为此指针向后偏移取8个字节
	long long** p =(long long **) & a;
	/* p[0]取前8个字节的内容，则拿到一级指针的地址，此时p[0]的类型为long
	 long*,p[0][0]则拿到虚函数的地址，此时的地址为long long 类型，
	 需要转换成函数指针类型 */
	auto q = (void(*)())p[0][0];  //q拿到虚函数的地址
	q(); //调用虚函数1
	q = (void(*)())p[0][1];
	q(); //调用虚函数2

	return 0;
}

输出结果
我是虚函数1
我是虚函数2

经过调式发现用虚类创建的对象中确实存在着二级指针

在这里插入图片描述

  1. 纯虚函数

注意要点：

  1. 纯虚函数的写法：virtual 返回类型 函数名（）= 0;
  2. 具有纯虚函数的类是无法创建对象的，但是可以创建指针如：类型* p = NULL;
  3. 如果父类有纯虚函数，继承此父类的子类也无法创建对象，除非在子类将纯虚函数实现例如：父类的纯虚函数是：virtual void print() = 0;,则子类的实现写法是：virtual void print(){}; virtual 可写可不写。

抽象类：具有纯虚函数的类为抽象类。

多态

注意要点：

1.父类没虚函数：

  1. 当父类指针拿到父类对象的地址时，父类指针会指向父类。
  2. 当父类指针拿到子类对象地址时，父类指针还是会指向父类。

2.父类有虚函数：

  1. 当父类指针拿到父类对象的地址时，父类指针会指向父类。
  2. 当父类指针拿到子类对象地址时，父类指针会指向子类。

总结：
3. 父类没虚函数时，我们看指针类型，就知道它指向谁。
4. 父类有虚函数时，我们看对象类型，就知道它指向谁。

代码实现
此时是父类没虚函数的情况

#include<iostream>
#include<string>
using namespace std;

class A
{
public:
	void print()
	{
		cout << "A" << endl;
	}
};

class B :public A
{
public:
	void print()
	{
		cout << "B" << endl;
	}
};

int main()
{
	A* pa = new A;
	pa->print();
	pa = new B;
	pa->print();
	
	return 0;
}

输出结果
A
A

此时是父类有虚函数的情况

#include<iostream>
#include<string>
using namespace std;

class A
{
public:
	//虚函数
	virtual void print()
	{
		cout << "A" << endl;
	}
};

class B :public A
{
public:
	void print()
	{
		cout << "B" << endl;
	}
};

int main()
{
	A* pa = new A;
	pa->print();
	pa = new B;
	pa->print();
	
	return 0;
}

输出结果
A
B

虚析构

#include<iostream>
#include<string>
using namespace std;

class A
{
public:
	virtual void print()
	{
		cout << "A" << endl;
	}
	~A()
	{
		cout << "A被析构啦~" << endl;
	}
};

class B :public A
{
public:
	void print()
	{
		cout << "B" << endl;
	}
	~B()
	{
		cout << "B被析构啦~" << endl;
	}
};

int main()
{
	A* pa = new B;
	delete pa;
	return 0;
}

输出结果
A被析构啦~

你会放发现我开辟了B类，结果却没释放刚刚开辟的内存，只释放了父类中的内存，这样会导致内存泄露。针对这一情况，C++引入了虚析构函数很好的解决了此问题

看代码

#include<iostream>
#include<string>
using namespace std;

class A
{
public:
	virtual void print()
	{
		cout << "A" << endl;
	}
	virtual ~A()
	{
		cout << "A被析构啦~" << endl;
	}
};

class B :public A
{
public:
	void print()
	{
		cout << "B" << endl;
	}
	~B()
	{
		cout << "B被析构啦~" << endl;
	}
};

int main()
{
	A* pa = new B;
	delete pa;
	return 0;
}


输出结果
B被析构啦~
A被析构啦~

完

小亦苦学编程
关注
  • 47
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【C++入门教程】学习笔记4——继承和多态
qq_42823184的博客
02-13 172
【C++入门教程】学习笔记4——继承和多态
C++虚函数多态和纯虚函数多态的经典示例源码
02-25
虚函数是C++中实现多态的基础。当在一个基类中声明一个虚函数时，这个函数可以在派生类中被重写，从而允许通过基类指针或引用调用派生类的版本。这样，即使不知道对象的确切类型，也可以执行适当的成员函数。例如： ...
C++学习笔记（3）——多态与虚函数
Mount256的博客
07-23 276
文章目录一、多态的概念 一、多态的概念 “多态”指的是同一名字的事物可以完成不同的功能。多态可以分为两种： 编译时的多态：即函数、运算符的重载、对重载函数的调用，在编译时就能根据实参确定应该调用哪个函数 运行时的多态：与继承、虚函数有关 虚函数，就是在声明前加了virtual关键字的成员函数。静态成员函数不能是虚函数。包含虚函数的类称为“多态”。下面是一个程序例子： #include<iostream> using namespace std; class A{ public: //一定
C++学习笔记（8）—— 虚函数与多态
weixin_44228389的博客
09-27 317
C++
[C++]学习笔记——多态
iluvia的博客
06-01 109
并非所有都要用虚析构、纯虚析构，此题比较特殊，因为子类中有数据被开辟到了堆区，所以必须走子类中的析构代码，如果只用多态走不到子类析构代码，所以我们在父类中才加上虚析构，纯虚析构。既要使用纯虚函数，又要释放父类在堆区中的数据，就需要使用类内纯虚函数声明，类外写实现的写法。搞清楚原理：虚函数相当于一个指针，被继承时，如果子类写了一模一样的函数，内容就会被覆盖。在多态中，通常父类中的虚函数的实现是毫无意义的，主要都是调用子类重写的内容。用引用也可以，引用不用手动释放内存，指针不用实例化对象，各有优劣。
C++中的虚函数表、强制类型转换、I/O流等——学习笔记
Love丶伊卡洛斯
08-21 440
一、虚函数表 什么是虚函数表，在C++的类中，一旦成员函数中有虚函数，这个类中就会多一个虚函数表指针，这个指针指向一个虚函数表，表里面记录了 这个类中所有的虚函数，当这个类被继承，它的子类中也会有一个虚函数表（不管子类中有没有虚函数），如果子类的成员函数中有函数签名与父 类的虚函数一样，就会用子类中的函数体寒它在虚函数表中的位置，这样就达到了覆盖的效果。 当通过类指针或引用调用函数时，会根据对象中...
C++学习笔记——继承与多态
weixin_45121946的博客
06-18 765
继承与多态都是C++中很重要的两个概念，也是相比起C语言的优势所在，下面就来总结一下C++中继承与多态的概念以及简单用法！ 一.继承 1.1 什么是继承？ 面向对象思想是一种跟家符合人类思维的思想，一开始我还不怎么理解这句话，但是随着对C++以及面向对象思想的学习，我越发感觉到这句话的意义所在。 因为C++中的一大特点，封装的存在，将一类对象的共同特点，共有的成员和方法封装成类，但是，不可能每一类对象都要从头进行封装，就像游戏给一个英雄添加了一项新技能技能，总不能重头在创建一个新的英雄类吧，而且，在升级系统
C++学习笔记——多态
不想随波逐流的大学生一枚，我们每个人都在努力奔跑
04-22 471
多态的详细介绍，多态就是父类指针或者引用指向子类对象。在程序设计中多利用多态。
C++学习笔记——（六）多态、纯虚函数、模板函数
miyuexingchen的专栏
11-24 1049
注：编码工具是CLion+Cygwin64 目录 类属性为对象时的初始化方式 有继承关系时，子类和父类的构造和析构函数执行顺序 多态 几种常见说法 动态多态(重写) 静态多态(重载) 纯虚函数 类中函数部分为纯虚函数 类中函数全部为纯虚函数 全纯虚函数类模拟登陆回调 模板函数 类属性为对象时的初始化方式 #include <iostream> using namespace std; class Pet{ public: string name;
C++学习笔记 —— 多态
Charles Ren's Tech Blog
02-21 351
文章目录什么是多态多态的使用静态连编动态连编多态的好处计算器例子纯虚函数和抽象类虚析构和纯虚析构向上转型和向下转型向下转型向上转型发生了多态 什么是多态 父类引用或者指针指向子类对象。 编译时多态（静态连编）：函数和运算符重载。编译阶段就确定了地址。 运行时多态（动态连编）：通常说的多态。 多态的使用 使用条件： 父类中函数为虚函数 子类继承父类并重写该虚函数，子类virtual可写可不写 父类...
EDA/PLD中的C++虚函数
11-07
　虚函数是在类中被声明为virtual的成员函数，当编译器看到通过指针或引用调用此类函数时，对其执行晚绑定，即通过指针（或引用）指向的类的类型信息来决定该函数是哪个类的。通常此类指针或引用都声明为基类的，它...
c++继承与多态，虚函数实例
04-26
虚函数在实现多态中扮演着关键角色，它可以确保程序在运行时能够调用到正确的方法，即便对象的实际类型与指针或引用声明的类型不同。 首先，让我们深入理解“虚函数”这一概念。在C++中，虚函数通过在基类中使用`...
实例002——使用虚函数实现运行时多态.zip
01-08
本实例“实例002——使用虚函数实现运行时多态”着重于如何通过虚函数来实现这一功能。运行时多态允许我们通过基类指针或引用调用派生类重写的成员函数，即使在编译时不知道具体对象的类型。下面将详细介绍这一概念...
深入解析C++中的虚函数与多态
01-21
1.C++中的虚函数C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是...
Python编程学习第一篇——Python零基础快速入门（六）（4）异常处理
urhero的专栏
07-25 377
我们已经了解了Python的基本数据类型、变量和基本的逻辑控制语句，基于这些基础知识可以编写一些小程序了，但是在写程序的时候我们会发现，有时候程序并不是按我们预期的方向执行，有的直接报错，有的没有报错，却并未得到我们预期的结果。在这个例子中，除数为0会引发ZeroDivisionError异常，我们将异常信息赋值给变量e，并输出"除数不能为0"和异常信息。在这个例子中，由于除数不为0，所以没有发生ZeroDivisionError异常，代码会执行else语句块，并输出结果2.0。
AvaloniaUI的学习
最新发布
lishuangquan1987的博客
07-25 937
官方中文文档：https://docs.avaloniaui.net/zh-Hans/docs/welcome。
学习日志：JVM垃圾回收
weixin_46117680的博客
07-23 1025
当需要排查各种内存溢出问题、当垃圾收集成为系统达到更高并发的瓶颈时，我们就需要对这些“自动化”的技术实施必要的监控和调节。可达性算法中描述的对象引用，一般指的是强引用，即是GCRoot对象对普通对象有引用关系，只要这层关系存在普通对象就不会被回收。
前端学习1——自学习梳理
qq_63125992的博客
07-24 397
【代码】前端学习1——自学习梳理。
C++虚函数详解：继承、多态与友元
在C++中，纯虚函数是一个重要的概念，它在类继承与虚函数的设计中起着核心作用。纯虚函数的意义在于提供一个函数的框架，但不提供具体的实现，而是由派生类来完成。在基类中，通过`virtual`关键字声明一个函数为纯虚...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值