浅谈C++|多态篇

已于 2023-09-16 22:47:48 修改
阅读量157 收藏
点赞数
文章标签： c++ 开发语言
于 2023-09-16 22:47:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73731708/article/details/132927521
版权
本文详细介绍了C++中的多态，包括静态多态（函数重载和运算符重载）、动态多态（通过虚函数实现），并探讨了抽象类、纯虚函数、虚析构的概念及其应用。通过实例展示了多态的优势和使用技巧，以及解决子类析构问题的方法。
摘要由CSDN通过智能技术生成

1.多态的基本概念

多态是C++面向对象三大特性之一多态分为两类
1. 静态多态:函数重载和运算符重载属于静态多态，复用函数名·

2.动态多态:派生类和虚函数实现运行时多态
静态多态和动态多态区别:
·静态多态的函数地址早绑定–编译阶段确定函数地址

·动态多态的函数地址晚绑定–运行阶段确定函数地址下面通过案例进行讲解多态

动态多态满足条件

1、有继承关系
2、子类重写父类的虚函数

动态多态使用
父类的指针或者引用执行子类对象

重写:函数返回值类型函数名参数列表完全—致称为重写

 静态多态代码：

#include <iostream>
using namespace std;
class dongwu {
public:
	void speak() {
		cout << "动物叫" << endl;
	}
};

class cat :public dongwu {
	void speak() {
		cout << "猫叫" << endl;
	}
};
//早绑定，编译阶段就确定函数的地址

void speak(dongwu& p) {
	p.speak();
}
void fun() {
	cat p;
	speak(p);
}
int main() {
	fun();
	cat p;
	//发生隐式转换,只能把儿子转为父亲，退化
	dongwu m = p;
	m.speak();
	return 0;
}

注意转化，以及早绑定的特性是执行当前的类型的函数，不执行儿子的函数

动态动态代码： 

#include <iostream>
using namespace std;
class dongwu {
public:
	//virtual虚函数关键字
	virtual void speak() {
		cout << "动物叫" << endl;
	}
};

class cat :public dongwu {
	//子类的virtual可加可不加
	virtual void speak() {
		cout << "猫叫" << endl;
	}
};

//晚绑定，执行子类的函数
void speak(dongwu& p) {
	p.speak();
}
void fun() {
	cat p;
	speak(p);
}
int main() {
	fun();
	
	return 0;
}

二.多态的底层原理

我们先看以下代码：

#include <iostream>
using namespace std;
class father1 {
public:
	void speak() {
		cout << "动物叫" << endl;
	}
};
class father2 {
public:
	virtual void speak() {
		cout << "动物叫" << endl;
	}
};
int main() {
	cout << sizeof(father1) << endl;
	cout << sizeof(father2) << endl;

	return 0;
}

 当类的成员函数加入虚函数关键字后，会发现类的大小发生了改变。此时类的内部结构。此时类的内部会多一个指针虚函数（表）指针，虚函数指针指向虚函数表，虚函数表中存储虚函数的入口地址。

那么当派生类继承基类后，如果成员函数没有重名，那么会完全继承父类的结构。 

 

 但是当派生类，重写基函数的虚函数时，派生类中的虚函数表会发生改变，此时虚函数表指向派生类的虚函数，基类的虚函数被覆盖。

 

 此时，我们有派生类隐式转换为基类时，虚函数表中的内容并不改变，此时调用虚函数，执行的是派生类的虚函数。

三.多态的优点 

1、组织结构清晰

2、可读性强

3、对于前期和后期扩展以及维护性高

 普通计算机类:

#include <iostream>
using namespace std;
class jisuanqi {
public:
	int a, b;
	int jisuan(string fu) {
		if (fu == "+") {
			return a + b;
		}
		else if (fu == "-") {
			return a - b;
		}
		else if (fu == "*") {
			return a * b;
		}
	}
};
void fun() {
	jisuanqi q;
	q.a = 200;
	q.b = 100;
	cout << q.a << " - " << q.b << " = " << q.jisuan("-") << endl;
	cout << q.a << " + " << q.b << " = " << q.jisuan("+") << endl;
	cout << q.a << " * " << q.b << " = " << q.jisuan("*") << endl;

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

 多态计算机类：

#include <iostream>
using namespace std;
class jisuanqi {
public:
	int a;
	int b;
	virtual int jisuan() {
		return 0;
	}
};

class add :public jisuanqi {
	virtual int jisuan() {
		return a+b;
	}
};

class jian :public jisuanqi {
	virtual int jisuan() {
		return a - b;
	}
};

class cheng:public jisuanqi {
	virtual int jisuan() {
		return a * b;
	}
};

void fun() {
	jisuanqi* p = new add;
	p->a = 200;
	p->b = 100;
	cout << p->a << " + " << p->b << " = " << p->jisuan()<<endl;
	delete p;
	
	p = new jian;
	p->a = 200;
	p->b = 100;
	cout << p->a << " - " << p->b << " = " << p->jisuan()<<endl;
	delete p;


	p = new cheng;
	p->a = 200;
	p->b = 100;
	cout << p->a << " * " << p->b << " = " << p->jisuan()<<endl;
	delete p;
}
int main() {
	fun();
	return 0;
}

四.纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容因此可以将虚函数改为纯虚函数。当类中有了纯虚函数，这个类也称为抽象类

纯虚函数语法: virtual    返回值类型   函数名︰（参数列表）= 0 ;

抽象类特点:
    ·无法实例化对象
    ·子类必须重写抽象类中的纯虚函数，否则也属于抽象类
 

 代码：

#include <iostream>
using namespace std;

class father {
public:
	//纯虚函数
	virtual void fun() = 0;
};


class son :public father{
public:
	void fun() {
		cout << "我是sond" << endl;
	}
};

void fun() {
	//多态f必须是指针或者引用
	//father f; 报错不可实例化
	father* f = new son;
	f->fun();
}
int main() {
	fun();
	return 0;
}

案例制作饮品：

#include <iostream>
using namespace std;
class father {
public:
	virtual void zhushui() = 0;
	virtual void chongpao() = 0;
	virtual void daoru() = 0;
	virtual void jialiao() = 0;
	void fun() {
		zhushui();
		chongpao();
		daoru();
		jialiao();
	}
};

class tea :public father{
	void zhushui() {
		cout << "煮山泉水" << endl;
	};
	void chongpao() {
		cout << "冲茶" << endl;
	};
	void daoru() {
		cout << "倒入茶杯中" << endl;
	};
	void jialiao() {
		cout << "加入枸杞" << endl;
	};
};

class kafei : public father{
	void zhushui() {
		cout << "煮水" << endl;
	};
	void chongpao() {
		cout << "冲咖啡" << endl;
	};
	void daoru() {
		cout << "倒入咖啡杯中" << endl;
	};
	void jialiao() {
		cout << "加入奶和糖" << endl;
	};
};
//函数接口
void fun(father* p) {
	p->fun();
	delete p;
}
int main() {
	fun(new tea);
	cout << "----------" << endl;
	fun(new kafei);
	return 0;
}

五. 虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方式:

将父类中的析构函数改为虚析构或者纯虚析构


虚析构和纯虚析构共性:
·可以解决父类指针释放子类对象·都需要有具体的函数实现


虚析构和纯虚析构区别:
·如果是纯虚析构，该类属于抽象类，无法实例化对象

代码： 

#include <iostream>
using namespace std;
class father {
public:
	//纯虚函数
	virtual void fun() =0;
	father() {
		cout << "father构造函数" << endl;
	}
	~father() {
		cout << "father析构函数" << endl;
	}
};

class son :public father {
public:
	//堆区开辟数据
	son(int age) {
		cout << "son构造函数" << endl;
		this->age = new int(age);
	}

	~son() {
		cout << "son析构函数" << endl;
		if (this->age != NULL) {
			delete age;
			age = NULL;
		}
	}
	void fun() {
		cout << *age<< "son的fun函数调用" << endl;
	}
	int* age;
};
void fun() {
	
	father* p = new son(21);
	delete p;
}
int main() {
	fun();
	return 0;
}

如图，当发生多态时，基类并不会调用子类的析构函数，当子类中含有堆区开辟的空间时。会造成内存泄漏。此时需要虚析构或纯虚析构来解决。

虚析构代码： 

#include <iostream>
using namespace std;
class father {
public:
	//纯虚函数
	virtual void fun() =0;
	father() {
		cout << "father构造函数" << endl;
	}
	virtual ~father() {
		cout << "father析构函数" << endl;
	}
};

class son :public father {
public:
	//堆区开辟数据
	son(int age) {
		cout << "son构造函数" << endl;
		this->age = new int(age);
	}

	~son() {
		cout << "son析构函数" << endl;
		if (this->age != NULL) {
			delete age;
			age = NULL;
		}
	}
	void fun() {
		cout << *age<< "son的fun函数调用" << endl;
	}
	int* age;
};
void fun() {
	
	father* p = new son(21);
	delete p;
}
int main() {
	fun();
	return 0;
}

纯虚析构：

#include <iostream>
using namespace std;
class father {
public:
	//纯虚函数
	virtual void fun() =0;
	father() {
		cout << "father构造函数" << endl;
	}
	virtual ~father() = 0;
};
//纯虚函数必须
father::~father()
{
	cout << "father析构函数" << endl;
}

class son :public father {
public:
	//堆区开辟数据
	son(int age) {
		cout << "son构造函数" << endl;
		this->age = new int(age);
	}

	~son() {
		cout << "son析构函数" << endl;
		if (this->age != NULL) {
			delete age;
			age = NULL;
		}
	}
	void fun() {
		cout << *age<< "son的fun函数调用" << endl;
	}
	int* age;
};
void fun() {
	
	father* p = new son(21);
	delete p;
}
int main() {
	fun();
	return 0;
}

案例计算机

#include <iostream>
using namespace std;

class CPU {
public:
	//纯虚函数
	virtual void func() = 0;
};

class  Memory_Module {
public:
	//纯虚函数
	virtual void func() = 0;
};

class  Graphics_card {
public:
	//纯虚函数
	virtual void func() = 0;
};


class CPU_intel : public CPU {
public:
	void func() {
		cout << "intel的CPU工作" << endl;
	}
};

class Graphics_card_intel : public Graphics_card {
public:
	void func() {
		cout << "intel的显卡工作" << endl;
	}
};



class Memory_Module_intel : public Memory_Module {
public:
	void func() {
		cout << "intel的内存条工作" << endl;
	}
};



class CPU_lenovo: public CPU {
public:
	void func() {
		cout << "联想的CPU工作" << endl;
	}
};

class Graphics_card_lenovo : public Graphics_card {
public:
	void func() {
		cout << "联想的显卡工作" << endl;
	}
};
class Memory_Module_lenovo : public Memory_Module {
public:
	void func() {
		cout << "联想的内存条工作" << endl;
	}
};
class computer {
public:
	//当传入的是子类时发生多态
	computer() {};
	computer(CPU* CPU , Memory_Module* m, Graphics_card* g) {
		this->cpu = CPU;
		this->m = m;
		this->g = g;
	}
	void work() {
		cpu->func();
		m->func();
		g->func();
	}
private:
	CPU* cpu;
	Memory_Module* m;
	Graphics_card* g;
};

void fun() {
	CPU_lenovo* c1 = new CPU_lenovo;
	CPU_intel* c2 = new CPU_intel;
	Graphics_card_intel* g1 = new Graphics_card_intel;
	Graphics_card_lenovo* g2 = new Graphics_card_lenovo;
	Memory_Module_intel* m1 = new Memory_Module_intel;
	Memory_Module_lenovo* m2 = new Memory_Module_lenovo;

	cout << "第一台电脑" << endl;
	computer* com = new computer(c1,m1,g1);
	com->work();
	cout << "********************************" << endl;
	cout << "第二台电脑" << endl;
	computer* com1 = new computer(c2, m2, g2);
	
	com1->work();
}
int main() {
	fun();
	return 0;
}

左手的月光
关注
浅谈C++多态的定义与实现
qq_42402262的博客
10-21 119
1. 多态的概念 多态：通俗的来说，就是同一件事物，在不同场景下表现啊出的不同的状态。 例如：买票（普通人全价票、学生半价票、军人优先）。 2.多态的定义及实现 2.1 多态的实现条件—必须在继承体系中 基类中必须有虚函数（被virtual修饰的函数），派生类必须对基类中的虚函数进行重写 必须通过基类的指针或引用调用虚函数 class Person { public: virtual voi...
浅谈C++多态实现原理（虚继承的奥秘）
机器学习
12-24 1024
根据我的已有知识，如果要实现C++的多态，那么，基类中相应的函数必须被声明为虚函数（或纯虚函数）。举个例子： class Point { public: Point(float x = 0.0, float y = 0.0) : _x(x), _y(y) { } virtual float z(); //virtual function protected: float _x, _y; }...
浅谈C++多态
qq13955的博客
11-21 448
什么是多态？ 多态性（polymorphism）据说最早源自希腊语，从字面上理解就是多种形态，多种形式。具体到C++这种面向对象（OOP）的语言中，其实就是“一种接口，多种实现（方法）”。 多态可分为静态多态和动态多态，具体的分类情况如下： 静态多态和动态多态的区别其实只是在什么时候将函数实现和函数调用关联起来，是在编译时期还是运行时期，即函数地址是早绑定还是晚绑定的？ 静态多态是指在编译期间就可以确定函数的调用地址，并生产代码，这就是静态的，也就是说地址是早早绑定的，静态多态也往往被叫做静态联编。
【C++】浅谈多态
m0_62179366的博客
10-23 1217
C++多态相关知识详解
基于代码浅谈C++多态
weixin_44179371的博客
05-30 170
浅谈C++多态 1、多态是啥？ 多态按理来说应该是面向对象编程的一个核心知识点了。多态即字面，“多”多种，“态”形态的意思。当然，这里的多种形态指的是面向对象时，用相类似的方式来处理不同类似的对象。多态这种行为被称为“子类型多态”，往往在继承层次结构中来实现。 2、为啥需要这个多态行为？ 举个例子，当你的派生类从基类中派生，继承了基类中的某些动作，并且还将该动作修改了。如下： class Animal { public: void die() { cout << "will die!"
浅谈C++多态&多态对象模型
Blessing_zf的博客
08-01 539
多态所谓多态，其实就是“多种形态”，C++的多态分为静态多态和动态多态。 1. 静态多态就是重载，因为是在编译期决议确定，所以称为静态多态。 2. 动态多态就是通过继承重写基类的虚函数实现的多态，因为是在运⾏时决议确定，所以称为动态多态。C++中虚函数的主要作⽤——就是实现多态。简单说⽗类的指针/引⽤调⽤重写的虚函数，当⽗类指针/引⽤指向⽗类对象时调⽤的是⽗类的虚函数，指向⼦类对象时调⽤的是⼦类
浅谈C++“多态”的一些现象
心之所向，一如既往
03-07 381
多态的概念  多态：一词最初来源于希腊语，意思是具有多种形式或形态的情形，在C++语言中多态有着更广泛的含义。 静态多态  编译器在编译期间完成的，编译器根据函数实参的类型(可能会进行隐式类型转换)，可推断出要调用那个函数，如果有对应的函数就调用该函数，否则出现编译错误。 就像一个同样逻辑的加法函数，但是类型不一样，我们在使用时编译器自己就会识别到底应该使用哪个函数。例如如下代码：int Add(
【C/C++】浅谈C++多态
Hello，My Friends~
06-03 319
浅谈C++多态什么是多态？虚拟继承函数复用那什么时候会用到多态呢？ 什么是多态？ 多态是C++三大特性之一，要理解多态，首先得知道什么是多态。多态是指父类指针指向子类对象，实质上就是类的虚拟继承和函数复用。 虚拟继承 虚拟继承是指添加了virtual关键字的类成员： class A{ public： **virtual** void func1(int a){ cout<<"this is A"<<endl; } } 函数复用 如父类对象有func1函数，子类对象继承自父类 cl
浅谈c++继承、多态及继承与多态的区别
qq_37185716的博客
07-13 1492
继承：类与类之间可以共用代码，实现代码重用。 基类：被继承的类，即父亲类。 派生类：继承的类，拿来主义类，即儿子类。 继承方式： private：私有继承 基类private成员 不能继承 基类public、protected成员,可以继承,在派生类中相当于是private访问 public:公有继承: 基类private成员 不能继承 基类public成员,可以继承,在派生
浅谈c++的精髓之继承和多态
09-10
### 面向对象编程与C++中的继承和多态 #### 1. 面向对象编程思想的诞生 面向对象编程（Object-Oriented Programming, OOP）的引入，是为了克服传统面向过程编程的一些局限性。面向过程编程，如C语言，更侧重于按...
浅谈C++中虚函数实现原理揭秘
12-25
通过基类指针做虚函数调 用时（也就是做多态调用时），编译器静态地插入取得这个V P T R，并在V TA B L E表中查找函数地址的代码，这样就能调用正确的函数使晚捆绑发生。为每个类设置V TA B L E、初始化V P T R、为...
浅谈C++重载、重写、重定义
09-02
在C++编程语言中，重载、重写和重定义是三个重要的概念，它们涉及到函数的多态性和作用域。下面将详细讲解这三个概念，并通过示例代码进行说明。 1. 重载（Overload） 重载是指在同一个作用域内，可以定义多个同名...
浅谈python使用多态跟不用多态的区别_python 面向对象之多态与绑定方法
weixin_39637260的博客
12-16 619
多态与多态性一，多态1，多态指的是一类事物有多种形态(python里面原生多态)1.1动物有多种形态：人，狗，猪import abcclass Animal(metaclass=abc.ABCMeta): #同一类事物:动物@abc.abstractmethoddef talk(self):passclass People(Animal): #动物的形态之一:人def talk(self):pri...
VScode中CMake无高亮（就是没有补全的提示）
Moapsw033的博客
10-15 252
原因就是：本地没有配置环境变量，解决方法是下一个cmake然后直接配置环境变量。在我学的过程中我发现我的CMake是这样的，如下图。这非常的难受，所以疯狂的找，最后是CMake报错有。如何配置环境变量就直接上网找就好了，很简单的，加油。但在教学视频里是这样的（如下图）
东方博宜OJ P1000-P1100题 C++ 和 Python 题解代码汇总
10-18 208
【代码】东方博宜OJ P1000-P1100题 C++ 和 Python 题解代码汇总。
汉诺塔问题和青蛙跳台阶问题（c语言）
2402_86350741的博客
10-18 315
这俩道题都是利用到了函数递归的思想，其中汉诺塔问题较难理解，青蛙跳台阶则较简单。
百度IDGC++一面-面经总结
MatsumotoChrikk
10-18 442
虚函数出现在多态、继承的情况中，在基类定义一个函数，在派生类可以重写。这也是运行时多态，虚函数就是函数前加上virtual关键字依赖虚函数表和虚表指针，只要有虚函数的类-就生成一个虚函数表。虚表指针指向这个虚函数表。查找对应的，调用函数。流量控制使用滑动窗口协议来控制流量。接收方通过广告窗口大小告诉发送方它能够接收的缓冲区大小，从而防止发送方过快地发送数据，避免接收方的缓冲区溢出。拥塞控制TCP 拥塞控制机制通过调整数据传输速率来防止网络拥塞。
C++中的CRTP
最新发布
moter的专栏
10-18 567
我们知道，要定义派生类肯定需要知道基类的类型，而在使用类模板来实例化一个模板类时又得需要知道模板的实参类型，在这里实例化基类时的实参类型又是派生类的类型。CRTP基类是类模板，基类实例化之后，和派生类是一一对应的，即一个基类只能派生一个子类，而模板参数化this指针的实现方式是基类只有一个，而且是非模板类，它的派生类可以有多个，但是每定义一个派生类，在该基类中都会使用派生类类型实例化出一个对应的interface()函数，也就是在基类中会有多个interface()成员函数和它的派生类一一对应。
【C语言】指针与函数：传值与传址
我的我的博客
10-17 501
函数在使用的时候，给到的形式参数属于局部变量，仅在函数体内部有效。 1. 传值，对于两个值的交换，不影响函数调用之前的数值。这个就是传值，传递的是实参。 2. 传址，如果想通过函数来改变原本两个变量的值，那么需要传递地址。 3. 另外一种方式就是定义**全局变量**，参数不进行传递。可以直接实现在自定义函数体内，改变main函数中、或者其他函数中的值。
C++值多态：传统多态与类型擦除的实战应用
本文将深入探讨C++中的值多态，特别是其与传统多态和类型擦除的区别与联系。值多态是一种在单继承场景下，结合了值语义和多态性的编程技术，它允许程序员在不使用指针或引用的情况下，以统一的方式处理不同类型的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

左手的月光

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值