C++多态学习笔记

于 2022-11-04 17:30:31 发布
阅读量528 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44653420/article/details/127693229
版权

C++多态学习笔记

一、多态概述

 同一个操作作用于不同的对象，可以有不同的解释，会产生不同的效果，这就是多态

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class People
{
public:
	// 虚函数
	virtual void Mypro()
	{
		cout << "父类的虚函数" << endl;  // 在编译阶段就确定了调用speak这个函数 
	}
};

class xishi :public People
{
public:
	// 重写父类虚函数
	virtual void Mypro()
	{
		cout << "西施的虚函数" << endl;
	}
};

class wangzhaojun :public People
{
public:
	// 重写父类虚函数
	virtual void Mypro()
	{
		cout << "王昭君的虚函数" << endl;
	}
};

class diaochan :public People
{
public:
	// 重写父类虚函数
	virtual void Mypro()
	{
		cout << "貂蝉的虚函数" << endl;
	}
};

// 同一个操作
void doLogin(People* pro)
{
	pro->Mypro();
}

void test()
{
	// 创建不同的对象 会产生不同的效果


	People* pro = NULL;
	pro = new xishi;
	doLogin(pro);// 继承 向上转换   指针范围缩小
	delete pro;


	pro = new wangzhaojun;
	doLogin(pro);// 继承向上转换 
	delete pro;
}


int main()
{
	//test02();
	test();
	return EXIT_SUCCESS;
}

二、多态的作用

  • 可以解决项目中的紧耦合问题，提供程序的可扩展性
  • 应用程序不必为每一个实现子类的功能调用编写代码

三、多态发生的三个条件

  • 有多继承
  • 重写父类的虚函数
  • 父类指针指向子类对象

四、多态实现的原理

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

  • 编译器只要发现类中有虚函数，编译器就会创建一张表，表中存放类中所有的虚函数的入口地址

  • 编译器会在类对象中安插一个虚函数表指针，虚函数表指针指向本类的虚函数表

  • 虚函数表指针是从父类继承下来的，虚函数表指针指向父类的虚函数表，编译器未来初始化从父类继承过来的虚函数表指针，编译器在我们的所有构造函数中添加了初始化虚函数指针的代码，让从父类继承过来的虚函数表指针指向子类自己的虚函数表

  • 当编译器发现子类重写了父类的虚函数，那么子类重写的函数就会覆盖掉虚函数表对应的父类的函数

  • 当我们通过父类指针去调用speak函数时，编译器会根据animal指针指向的内存空间中的虚函数表指针找到speak函数

在这里插入图片描述
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class People
{
public:
	// 虚函数
	virtual void Mypro()
	{
		cout << "父类的虚函数" << endl;  // 在编译阶段就确定了调用speak这个函数 
	}
};

class xishi :public People
{
public:
	// 重写父类虚函数
	virtual void Mypro()
	{
		cout << "西施的虚函数" << endl;
	}
};

class wangzhaojun :public People
{
public:
	// 重写父类虚函数
	virtual void Mypro()
	{
		cout << "王昭君的虚函数" << endl;
	}
};

class diaochan :public People
{
public:
	// 重写父类虚函数
	virtual void Mypro()
	{
		cout << "貂蝉的虚函数" << endl;
	}
};

// 同一个操作
void doLogin(People* pro)
{
	pro->Mypro();
}

void test()
{
	// 创建不同的对象 会产生不同的效果
	People* pro = NULL;// 父类指针
	pro = new xishi;// 父类指针 指向子类对象
	doLogin(pro);// 继承 向上转换   指针范围缩小
	delete pro;

	pro = new wangzhaojun;
	doLogin(pro);// 继承向上转换 
	delete pro;
}


int main()
{
	//test02();
	test();
	return EXIT_SUCCESS;
}

将代码分成 抽象层 实现层 业务层

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

// 抽象层  很多函数不在这里实现 仅仅定义一下
class rule
{
public:
	virtual int getnum(int a, int b)
	{
		return 0;
	}
};

// 实现层  通过虚函数 实现不改变父类的基础上 扩展功能
// 所以实现层 可以有很多类
class plus_rule :public rule
{
public:
	virtual int getnum(int a, int b)
	{
		return a + b;// 重载父类的虚函数
	}
};

// 实现层代码
class miux_rule :public rule
{
public:
	virtual int getnum(int a, int b)
	{
		return a - b;// 重载父类的虚函数  做减法
	}
};


// 业务层  业务层调用抽象层的代码 通过抽象层的对象指针 （该指针指向实现层对象）
int doLogin(rule *cal)
{
	int a = 10;
	int b = 20;
	int ret = cal->getnum(a,b);// 函数的调用还是通过父类指针  父类指针指向子类对象
	return ret;
}

// 测试
void test()
{
	rule* r = NULL;
	r = new plus_rule;
	cout << doLogin(r) << endl;
	delete r;

	
	rule *m = new miux_rule;// 父类指针指向子类对象   向上转换
	cout << doLogin(m) << endl;// 调用不同实现层的代码
	delete m;

}

int main()
{
	//test02();
	test();
	return EXIT_SUCCESS;
}

开闭原则：对修改源代码关闭，对扩展新功能进行开发

一般情况下，都会将抽象层的被重载函数写成纯虚函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

// 抽象层  很多函数不在这里实现 仅仅定义一下
class rule
{
public:
	virtual int getnum(int a, int b) = 0;
};

// 实现层  通过虚函数 实现不改变父类的基础上 扩展功能
// 所以实现层 可以有很多类
class plus_rule :public rule
{
public:
	virtual int getnum(int a, int b)
	{
		return a + b;// 重载父类的虚函数
	}
};

// 实现层代码
class miux_rule :public rule
{
public:
	virtual int getnum(int a, int b)
	{
		return a - b;// 重载父类的虚函数  做减法
	}
};


// 业务层  业务层调用抽象层的代码 通过抽象层的对象指针 （该指针指向实现层对象）
int doLogin(rule *cal)
{
	int a = 10;
	int b = 20;
	int ret = cal->getnum(a,b);// 函数的调用还是通过父类指针  父类指针指向子类对象
	return ret;
}

// 测试
void test()
{
	rule* r = NULL;
	r = new plus_rule;
	cout << doLogin(r) << endl;
	delete r;

	
	rule *m = new miux_rule;// 父类指针指向子类对象   向上转换
	cout << doLogin(m) << endl;// 调用不同实现层的代码
	delete m;

}

int main()
{
	//test02();
	test();
	return EXIT_SUCCESS;
}

有纯虚函数的类叫做抽象类，不可以实例化对象

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

// 抽象层  很多函数不在这里实现 仅仅定义一下
class rule
{
public:
	virtual int getnum(int a, int b) = 0;
};

// 实现层  通过虚函数 实现不改变父类的基础上 扩展功能
// 所以实现层 可以有很多类
class plus_rule :public rule
{
public:
	virtual int getnum(int a, int b)
	{
		return a + b;// 重载父类的虚函数
	}
};

// 实现层代码
class miux_rule :public rule
{
public:
	virtual int getnum(int a, int b)
	{
		return a - b;// 重载父类的虚函数  做减法
	}
};


// 业务层  业务层调用抽象层的代码 通过抽象层的对象指针 （该指针指向实现层对象）
int doLogin(rule *cal)
{
	int a = 10;
	int b = 20;
	int ret = cal->getnum(a,b);// 函数的调用还是通过父类指针  父类指针指向子类对象
	return ret;
}

// 测试
void test()
{
	rule* r = NULL;
	r = new plus_rule;
	cout << doLogin(r) << endl;
	delete r;

	
	rule *m = new miux_rule;// 父类指针指向子类对象   向上转换
	cout << doLogin(m) << endl;// 调用不同实现层的代码
	delete m;

}

int main()
{
	//test02();
	test();
	return EXIT_SUCCESS;
}

子类继承抽象类，子类必须实现抽象类的所有纯虚函数，不然子类也变为抽象类

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;


class Maker
{
public:
	virtual void func1() = 0;
	virtual void func2() = 0;
};

// 子类需要实现父类的所有虚函数
class Son :public Maker
{
	virtual void func1()
	{

	}
	virtual void func2()
	{

	}
};

void test()
{
	Son s;
}

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

五、接口的定义

 所谓的接口，就是将内部实现细节封装起来，外部用户通过预留的接口可以使用接口的功能而不需要知晓内部具体的细节，C++中，通过类实现面对对象的编程，在基类中只给出纯虚函数的声明，然后在派生类中实现纯虚函数的具体定义的方式实现接口，不同派生类实现接口的方式也不相同

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Father
{
public:
	virtual void func1() = 0;// 接口的声明
	virtual void func2(int a) = 0;
	virtual void func3(int a,int b) = 0;
};

class Son :public Father
{
public:
	virtual void func1()
	{

	}
	virtual void func2(int a)
	{

	}
	virtual void func3(int a,int b)
	{

	}
};


int main()
{

	return EXIT_SUCCESS;
}

六、模板方法模式

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Drink
{
public:
	//zhu
	virtual void Boil() = 0;

	// 冲泡
	virtual void Brew() = 0;

	// 导入杯中
	virtual void PourInCup() = 0;

	// 加点辅料
	virtual void addSonm() = 0; 

	// 模板方法  抽象类将所有的虚基类方法归纳 然后   实现层实现每一个方法
	void func()
	{
		Boil();
		Brew();
		PourInCup();
		addSonm();
	}

};


class Coffee :public Drink
{
public:

	//zhu
	virtual void Boil()
	{
		cout << "煮点露水" << endl;
	}

	// 冲泡
	virtual void Brew()
	{
		cout << "拿铁" << endl;
	}

	// 导入杯中
	virtual void PourInCup()
	{
		cout << "导入盆中" << endl;
	}

	// 加点辅料
	virtual void addSonm()
	{
		cout << "加点糖" << endl;
	}
};

class Tea :public Drink
{
public:
	//zhu
	virtual void Boil()
	{
		cout << "煮点露水" << endl;
	}

	// 冲泡
	virtual void Brew()
	{
		cout << "茶叶" << endl;
	}

	// 导入杯中
	virtual void PourInCup()
	{
		cout << "导入盆中" << endl;
	}

	// 加点辅料
	virtual void addSonm()
	{
		cout << "加点糖" << endl;
	}

};


void test()
{
	// 父类指针指向子类对象
	Drink* d = NULL;
	d = new Coffee;
	d->func();
	delete d;

	d = new Tea;
	d->func();
	delete d;
	d = NULL;
}

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

七、虚析构函数和纯虚析构函数

运行下面这段代码，因为静态联编：不会执行子类的析构函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	Animal()
	{
		cout << "Animal 的构造函数" << endl;
	}

	~Animal()
	{
		cout << "Animal 的析构函数" << endl;
	}
};

class Son :public Animal
{
public:
	Son()
	{
		cout << "Son的构造函数" << endl;
		pName = new char[64];// 新建一个堆
		memset(pName,0,64);// 初始化0  全部字节
		strcpy(pName,"如花");// 拷贝字符串
	}

	~Son()
	{
		cout << "Son的析构函数" << endl;
		if (pName != NULL)
		{
			delete[] pName;
			pName = NULL;
		}
	}
public:
	char* pName;
};

void test()
{
	Animal* animal = new Son;
	delete animal;
}

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

也就是，上面这段代码，基类指针指向了派生类对象，先执行基类的构造函数，然后执行子类的构造函数，但是delete的时候，只能执行基类的析构函数，不可以执行子类的析构函数

7.1 虚析构函数

虚析构函数是为了解决基类指针指向派生类对象，并使用基类指针释放派生类对象

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	Animal()
	{
		cout << "Animal 的构造函数" << endl;
	}

	// 虚析构函数可以调用子类的虚析构函数
	virtual ~Animal()
	{
		cout << "Animal 的析构函数" << endl;
	}
};

class Son :public Animal
{
public:
	Son()
	{
		cout << "Son的构造函数" << endl;
		pName = new char[64];// 新建一个堆
		memset(pName,0,64);// 初始化0  全部字节
		strcpy(pName,"如花");// 拷贝字符串
	}

	~Son()
	{
		cout << "Son的析构函数" << endl;
		if (pName != NULL)
		{
			delete[] pName;
			pName = NULL;
		}
	}
public:
	char* pName;
};

void test()
{
	Animal* animal = new Son;
	delete animal;
}

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

7.2 纯虚析构函数

纯虚析构函数，有纯虚析构函数的类是抽象类，不可以实例化对象

纯虚析构函数需要在类外实现

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	Animal()
	{
		cout << "Animal 的构造函数" << endl;
	}

	// 虚析构函数可以调用子类的虚析构函数
	virtual ~Animal() = 0;
};

// 在类外实现纯虚析构函数
Animal::~Animal()
{

}

class Son :public Animal
{
public:
	Son()
	{
		cout << "Son的构造函数" << endl;
		pName = new char[64];// 新建一个堆
		memset(pName,0,64);// 初始化0  全部字节
		strcpy(pName,"如花");// 拷贝字符串
	}

	~Son()
	{
		cout << "Son的析构函数" << endl;
		if (pName != NULL)
		{
			delete[] pName;
			pName = NULL;
		}
	}
public:
	char* pName;
};

void test()
{
	Animal* animal = new Son;
	delete animal;
}

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

虚析构函数和纯虚析构函数的区别：

  • 有纯虚析构函数的类是抽象类，不能实例对象 而且要在类外实现
  • 虚析构函数不需要在类外实现

八、重写重载重定义

  • 重载：同一作用域的同名函数
  • 重定义（隐藏）：有继承，子类（派生类）重新定义父类（基类）的同名成员（非Virtual函数）
  • 重写：有继承，子类（派生类）重写父类(基类)的virtual函数，函数返回值，函数名字，函数参数，必须和基类中的虚函数一致

九、父类引用子类对象

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:
	virtual void speak()
	{
		cout << "Animal 的构造函数" << endl;
	}
};

class Dog :public Animal
{
public:
	virtual void speak()
	{
		cout << "构造函数" << endl;
	}
};


void test()
{
	Animal &animal = Dog();
	//delete animal;
	animal.speak();
}

int main()
{
	test();
	return EXIT_SUCCESS;
}
少写代码少看论文多多睡觉
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
10.5 异常规范
芝麻软件工作室的专栏
06-15 556
◆ 1、异常规范（exception specification）是指：提供了一种方案，可以随着函数声明列出该函数可能抛出的异常，并保证该函数不会抛出任何其他类型的异常。例如，在stack类定义中可有：     void Push(const T&data) throw(pushOnFull) ;     T Pop() throw(popOnEmpty); //红色部分是异常规范
C++之回炉再造笔记--问题记录1
牵一只蜗牛去散步
05-06 818
目录 1--vs2017包含目录后，引入头文件失败 2--调试TensorRT程序，报“重写虚函数的限制性异常规范比基类虚成员函数少”的错误 3--编译Tensorrt测试程序时，报“无法解析的外部符号，该符号在函数中被引用”的错误 4--参考 1--vs2017包含目录后，引入头文件失败 可能原因：设置包含目录的平台与实际Debug的平台不一样。 举例：比如一开始本人设置的平台分别是x86和x64，在x64平台设置了包含目录，在x86的平台Debug无法引入头文件。 解决方法：更改平.
c++异常说明（exception specification）
qq_37185716的博客
07-31 2026
所谓的异常说明即throw（int（异常说明）） 在实际应用中要明智使用异常说明 原因： 1.编译器有时候能够在编译期间侦测到与exception specification不一样的行为，假设抛出了一个并为列与其 exception specification 的exception ，这个错误会在运行期间被检测出来，于是会调用unexpected函数，而unexpected会调用termi
c++学习笔记：多态
qq_60143666的博客
04-09 1078
c++面向对象三大特征之一的多态的基本语法！
C++进阶 #define与C++多态
Android小码家
09-05 282
前言： 说实在的当我们接触到真正的C++开发时,比如说MFC的一个简单项目，我们会发现我们却的不是基础知识，而是一种编码模式或者说模式，常常会出现一些我们看不懂的代码，其实这才是初学者正真缺少的一种‘编码感觉’,这是需要时间去磨练和感受的，书本上和别人的知道都帮不了你。 我现在要讲的是我在MFC的一个Demo中出现了大量的define宏定义，我发现原来宏定义可以这样玩； main...
C++学习笔记
04-01
C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。
P135~142C++类和对象多态学习笔记.docx
04-13
P135~142C++类和对象多态学习笔记.docx
C++ 核心编程 学习笔记
最新发布
05-11
内存分区模型： 程序运行前，程序运行后，new操作符 引用： 引用的基本使用，引用注意事项，...封装，对象的初始化和清理，C++对象模型和this指针，友元，运算符重载，继承，多态 文件操作： 文本文件，二进制文件
c++学习笔记（自己写的大约有30页）
05-18
C++学习笔记。C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，...
C++学习笔记- 面向对象 .md
11-13
C++学习笔记，博主个人向。内容是C++面对对象的，目录大致来源于菜鸟文档的C++面向对象，笔记是参考各种文章以及菜鸟文档改编的，内容包含C++类和对象（类定义和对象定义，类成员函数，类访问修饰符，友元函数，内联...
VisualC++ Exception Specifications
老骥伏枥，志在千里
11-28 1055
Exception Specifications这个词我成为“异常规格”，不知道是否准确，有更准确的希望大家布林刺激哦。 异常规格被用于指出一个函数能抛出什么样的异常。 函数可以抛出任何类型异常 void MyFunction(int i) throw(...); 函数不能抛出异常 void MyFunction(int i) throw(); 其等效于
C++11异常处理 noexcept
热门推荐
zkreats的博客
01-20 1万+
1.简介在C语言中，当程序的运行出现异常、错误时，如果我们想为这些异常、错误提供解决方案时，我们面临许多问题，如： （1）C语言没有提供统一（标准）的方式来处理错误； （2）无法保证错误会被正确的处理； （3）错误的传播也无法控制，特别是在函数的嵌套调用时； … …当程序在运行时发生错误，使得程序的继续运行变得没有意义时，C++中的异常机制给我们提供了一个解决方法。2.C++03 异常处
C++之多态学习笔记
weixin_63816825的博客
05-10 217
文章目录 一、多态是什么？ 二、多态相关知识 1.多态种类 2.种类的区别 三、编程例题讲解——动物多态 四、总结 前言 提示：这里可以添加本文要记录的大概内容： 其实关于C++也没有学习太多的东西，也不是什么大神，就是想通过写博客来做一下关于C++学习的笔记和大家分享自己在学习C++的时候一些理解，监督一下自己和大家，共同进步。 提示：以下是本篇文章正文内容，下面案例可供参考 一、多态是什么？ 多态是类的三大类：封装、继承、多态中的一类，多态多态，顾...
C++学习笔记-多态
cj5785
04-03 1389
多态作为面向对象的重要概念，在如何一门面向对象编程语言中都有着举足轻重的作用，学习多态，有助于更好地理多态的行为 多态性（Polymorphism）是指一个名字，多种语义；或界面相同，多种实现。 重载函数是多态性的一种简单形式。 虚函数允许函数调用与函数体的联系在运行时才进行，称为动态联编 静态联编 联编是指一个程序模块、代码之间互相关联的过程 静态联编，是程序的匹配、连接在编译阶段实现，也称为早...
C语言用宏实现静态多态
weixin_34194702的博客
03-11 172
2019独角兽企业重金招聘Python工程师标准>>> ...
用宏实现简单的多态　简单小技巧
JackyLau的专栏
06-12 877
#include #include #define List(X) \ struct list_##X \ {\ X data;\ struct list_##X *next;\ } typedef char * string; int main() { List(int) l1={1,NULL}; List(double) l2={2,NULL}; char *p=(char *)
C++：通过多态实现接口并生成dll和lib文件的小例子
己亥谷雨
07-21 629
1、接口声明头文件 首先声明一个形状基类，然后是三个派生类三角形、长方形和圆形。 基类中只有一个函数，getArea()输出面积 三个派生类分别对getArea()重载，分别有各自的构造函数 派生类的私有成员相同，都是一个前向类，和一个类指针 //ShapeInterface.h //接口声明头文件 #pragma once //在预编译器里添加 SHAPEINTERFACE_EXPORTS //指定为导出模式，后面的类名前也都要添加 SHAPEINTERFACE_API #ifdef SHA
C++实现轻量级RPC分布式网络通信框架
asdfadafd的博客
09-11 1965
2022/4/14更新：在我重新回顾这篇文章的时候，我觉得里面内容有点乱，主要还是因为RPC里面涉及到很多概念和知识点。本来代码内容就已经挺抽象了，还要结合各种概念，让人难以阅读，所以特地写了下面这一篇文章，梳理了RPC框架的基本原理和知识点，顺便拓展了一些RPC在实际应用中会遇到的问题。RPC框架基础篇 链接地址本次项目用C++实现了一个简单的RPC分布式网络通信框架，因此写下本篇文章梳理一下该框架的实现逻辑和相关知识点。
 c++多态学习例子
09-09
下面是一个简单的多态学习例子： ```python class Animal: def sound(self): pass class Dog(Animal): def sound(self): print("汪汪汪！") class Cat(Animal): def sound(self): print("喵喵喵！") def ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

少写代码少看论文多多睡觉

求打赏，求关注，求点赞

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

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

打赏作者

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

抵扣说明：

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

余额充值