C++经典问题_14 多态

已于 2022-04-03 16:53:09 修改
阅读量1k 收藏 3
点赞数
分类专栏： C++经典问答 文章标签： c++ c语言 开发语言
于 2022-04-03 15:05:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fioman_GYM/article/details/123923093
版权

文章目录

一. 多态的分类

① 两种多态的实现方式
  1. 静态多态: 函数重载和运算符重载属于静态多态,复用函数名.
  2. 动态多态: 派生类和虚函数实现运行时多态
② 静态多态和动态多态的区别
  1. 静态多态的函数地址早绑定 - 编译阶段确定函数地址
  2. 动态多态的函数地址晚绑定 - 运行阶段确定函数地址

二. 多态的实现方式

使用基类的引用或者指针指向子类的对象,可以调用子类的函数,就是实现通过基类指针或者引用根据指针的指向来动态的确定具体的子类的行为.

动态多态的满足条件

  1. 有继承关系
  2. 子类要重写父类的虚函数(函数名,函数参数列表,返回值都要相同)
  3. 父类的指针或者引用指向子类对象.

普通的静态绑定的函数例子(非虚函数),不会实现多态,地址早绑定,在编译阶段都根据类型确定好了

/*----------------------------------------------------------------
* 项目: Classical Question
* 作者: Fioman
* 邮箱: geym@hengdingzhineng.com
* 时间: 2022/3/22
* 格言: Talk is cheap,show me the code ^_^
//----------------------------------------------------------------*/

#include <iostream>
using namespace std;
class Animal
{
public:
	void speak()
	{
		cout << "动物在说话!" << endl;
	}
};

class Dog :public Animal
{
public:
	void speak()
	{
		cout << "小狗在说话!" << endl;
	}
};

// 这里地址早绑定,在编译阶段就确定了doSpeak会调用Animal里面的函数
// 这里就是算是传进来了Animal的子类,也不会调用子类的speak()函数
void doSpeak(Animal &animal)
{
	animal.speak();
}



int main()
{
	Animal animal;
	Dog dog;
	doSpeak(animal);
	doSpeak(dog); // 这里也调用的是动物在说话
	system("pause");
	return 0;
}

上面的例子说明,普通的函数在调用的时候,地址是早绑定的,也就是说,无论你传入的对象是基类还是子类,都会按照函数定义的时候那个类型去调用同一个函数,如果实现动态绑定呢,只需要在函数前面加上virtual,告诉编译器这个函数是要动态绑定的,在运行的时候根据引用的类型或者指向的类型去确定调用哪个函数

/*----------------------------------------------------------------
* 项目: Classical Question
* 作者: Fioman
* 邮箱: geym@hengdingzhineng.com
* 时间: 2022/3/22
* 格言: Talk is cheap,show me the code ^_^
//----------------------------------------------------------------*/

#include <iostream>
using namespace std;
class Animal
{
public:
	// 虚函数,编译器会在运行的时候根据实际的类型去确定调用哪个函数
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
class Cat :public Animal
{
public:
	// 虚函数,动态绑定
	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}
};

class Dog :public Animal
{
public:
	virtual void speak()
	{
		cout << "小狗在说话" << endl;
	}
};

class Cat :public Animal
{
public:
	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}
};

void doSpeak(Animal &animal)
{
	// 这里会根据animal的实际类型去选择对应的speak()函数执行
	animal.speak();
}

int main()
{
	Animal animal = Animal();
	doSpeak(animal); // 实际的引用对象是动物

	Dog dog = Dog();
	doSpeak(dog); // 实际的引用对象是狗

	Cat cat = Cat();
	doSpeak(cat); // 实际的引用对象是小猫

	system("pause");
	return 0;
}

结果:

三. 多态的原理剖析

① 普通的类占用的内存空间大小(没有成员变量,只有成员函数)
/*----------------------------------------------------------------
* 项目: Classical Question
* 作者: Fioman
* 邮箱: geym@hengdingzhineng.com
* 时间: 2022/3/22
* 格言: Talk is cheap,show me the code ^_^
//----------------------------------------------------------------*/

#include <iostream>
using namespace std;
class Animal
{
public:
	void speak()
	{
		cout << "动物在说话!" << endl;
	}
};

int main()
{
	Animal animal = Animal();
	// 普通的类,没有成员变量,占用一个字节的内存空间
	// 主要是用来把这个对象和其他的对象区分开来,有一个地址,可以用来实例化
	cout << "空类或者是没有成员变量的类占用的内存空间 = " << sizeof(animal) << endl;

	system("pause");
	return 0;
}

结果:

② 含有虚函数的类的占用内存空间大小
  1. 含有虚函数的时候,类占用的内存空间,除了成员变量还有一个虚函数指针,如果是x86是4个字节,如果是64位操作系统占用的是8个字节.
  2. 虚函数指针,指向了虚函数表,虚函数表里面存放的是虚函数的地址(也就是函数指针).
  3. 虚函数指针一般用vfptr表示,虚函数表一般用vftable表示.
/*----------------------------------------------------------------
* 项目: Classical Question
* 作者: Fioman
* 邮箱: geym@hengdingzhineng.com
* 时间: 2022/3/22
* 格言: Talk is cheap,show me the code ^_^
//----------------------------------------------------------------*/

#include <iostream>
using namespace std;
class Animal
{
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};

int main()
{
	Animal animal = Animal();
	int *p;
	cout << "指针占用的内存大小: " << sizeof(p) << endl;
	cout << "含有虚函数的类占用的内存空间大小: " << sizeof(animal) << endl;

	system("pause");
	return 0;
}

结果:

四. 多态带来的好处

  1. 代码组织结构清晰
  2. 可读性强
  3. 利于代码的扩展和维护
  4. 符合开闭原则(对修改关闭,对扩展开放)

举个例子,写一个计算数值的计算器类,可以实现加减的操作.

/*----------------------------------------------------------------
* 项目: Classical Question
* 作者: Fioman
* 邮箱: geym@hengdingzhineng.com
* 时间: 2022/3/22
* 格言: Talk is cheap,show me the code ^_^
//----------------------------------------------------------------*/

#include <iostream>
#include <string>
using namespace std;
class Calculator
{
public:
	Calculator(int a, int b):mNumber1(a),mNumber2(b)
	{

	}
	int getResult(string op)
	{
		if (op == "+")
		{
			return mNumber1 + mNumber2;
		}
		else if (op == "-")
		{
			return mNumber1 - mNumber2;
		}
	}

public:
	int mNumber1;
	int mNumber2;
};

int main()
{
	Calculator cal = Calculator(10, 20);
	string op = "+";
	cout << cal.mNumber1 << op << cal.mNumber2 << "=" << cal.getResult(op) << endl;
	op = "-";
	cout << cal.mNumber1 << op << cal.mNumber2 << "=" << cal.getResult(op) << endl;
	system("pause");
	return 0;
}

如果现在我们想实现乘除操作,就不得不修改原来的代码,在后面加额外的额分支.如果使用多态的技术,就不用修改原来的代码,
可以在原来的基础上使用.并且在使用的时候也可以用同一个接口去调用.

/*----------------------------------------------------------------
* 项目: Classical Question
* 作者: Fioman
* 邮箱: geym@hengdingzhineng.com
* 时间: 2022/3/22
* 格言: Talk is cheap,show me the code ^_^
//----------------------------------------------------------------*/
#include <iostream>
#include <string>
using namespace std;

// 创建一个计算器的基类
class AbstractCalculator
{
public:
	virtual int get_result() = 0; // 纯虚函数,本类不能实例化对象,并且派生类必须实现改函数
public:
	int mNumber1;
	int mNumber2;
};

// 扩展加法类
class Add :public AbstractCalculator
{
public:
	Add(int a, int b)
	{
		mNumber1 = a;
		mNumber2 = b;
	}
	int get_result()
	{
		return mNumber1 + mNumber2;
	}
};

// 扩展减法类
class Sub :public AbstractCalculator
{
public:
	Sub(int a, int b)
	{
		mNumber1 = a;
		mNumber2 = b;
	}
	int get_result()
	{
		return mNumber1 - mNumber2;
	}
};

// 扩展乘法类
class Mul :public AbstractCalculator
{
public:
	Mul(int a, int b)
	{
		mNumber1 = a;
		mNumber2 = b;
	}
	int get_result()
	{
		return mNumber1 * mNumber2;
	}
};

// 扩展除法类
class Div :public AbstractCalculator
{
public:
	Div(int a, int b)
	{
		mNumber1 = a;
		mNumber2 = b;
	}
	int get_result()
	{
		return mNumber1 / mNumber2;
	}
};



int main()
{
	AbstractCalculator *cal = new Add(10,20);
	cout << cal->mNumber1 << "+" << cal->mNumber2 << "=" << cal->get_result() << endl;
	// 使用完注意释放内存
	delete cal;
	cal = NULL;
	
	cal = new Sub(10, 20);
	cout << cal->mNumber1 << "-" << cal->mNumber2 << "=" << cal->get_result() << endl;
	delete cal;
	cal = NULL;

	cal = new Mul(10, 20);
	cout << cal->mNumber1 << "*" << cal->mNumber2 << "=" << cal->get_result() << endl;
	delete cal;
	cal = NULL;

	cal = new Div(20, 10);
	cout << cal->mNumber1 << "/" << cal->mNumber2 << "=" << cal->get_result() << endl;
	delete cal;
	cal = NULL;

	// 扩展其他的类一样的使用方式


	system("pause");
	return 0;
}

可以看出来,虽然多态的代码量变多了,但是逻辑和扩展上更容易扩展.结构上也更加的清晰,也很容易理解.

五. 纯虚函数和抽象类

① 纯虚函数的定义
  1. 虚函数在后面加上=0,这个函数就变成了纯虚函数.
  2. 语法: virtual void somefunction(void) = 0
② 纯虚函数的意义
  1. 在多态中,通常父类中的虚函数是毫无意义的,主要是调用子类重写的函数.
  2. 定义成纯虚函数,则其派生类,必须实现这个函数,就是派生类都必须实现自己行为,不然就会报错.
  3. 一旦一个类中有了纯虚函数,这个类就变成了抽象类,这个类就不能实例化,并且子类必须重写父类的纯虚函数,否在子类也是一个抽象类,也不能实例化.
  4. 如果定了纯虚函数,目的就是让子类去实现对这个函数的重写.
/*----------------------------------------------------------------
* 项目: Classical Question
* 作者: Fioman
* 邮箱: geym@hengdingzhineng.com
* 时间: 2022/3/22
* 格言: Talk is cheap,show me the code ^_^
//----------------------------------------------------------------*/

#include <iostream>
using namespace std;
class Base
{
public:
	// 纯虚函数,只要有一个纯虚函数,这个类就被称为是抽象类.
	// 抽象类的特点:
	// 1. 无法实例化对象
	// 2. 抽象类的子类 必须要重写父类的纯虚函数,否则子类也是抽象类.
	virtual void func() = 0;
};

class Derived :public Base
{
	virtual void func()
	{
		cout << "Derived:: func() 调用 !" << endl;
	}
};

int main()
{
	// Base b = Base(); 报错 抽象类不能实例化
	// Base* bPtr = new Base; 报错,抽象类不能实例化
	Base *b = new Derived;
	b->func();// 子类重新实现了纯虚函数,是可以实例化并且调用的
	delete b;
	b = NULL;
	system("pause");
	return 0;
}

六 . 多态的案例

/*----------------------------------------------------------------
* 项目: Classical Question
* 作者: Fioman
* 邮箱: geym@hengdingzhineng.com
* 时间: 2022/3/22
* 格言: Talk is cheap,show me the code ^_^
//----------------------------------------------------------------*/
#include <iostream>
using namespace std;

class AbstractDrinking
{
public:
	// 煮水
	virtual void boil() = 0;
	
	// 冲泡
	virtual void brew() = 0;

	// 倒入杯中
	virtual void pour_in_cup() = 0;

	// 加入辅料
	virtual void put_something() = 0;

	// 制作饮品
	void make_drink()
	{
		boil();
		brew();
		pour_in_cup();
		put_something();
	}
};

// 制作咖啡
class Coffee :public AbstractDrinking
{
	// 煮水
	virtual void boil()
	{
		cout << "煮农夫山泉" << endl;
	}

	// 冲泡
	virtual void brew()
	{
		cout << "冲泡咖啡" << endl;
	}

	// 倒入杯中
	virtual void pour_in_cup()
	{
		cout << "倒入杯中" << endl;
	}

	// 加入辅料
	virtual void put_something()
	{
		cout << "加入牛奶和糖" << endl;
	}
};

// 制作茶叶
class Tea :public AbstractDrinking
{
	// 煮水
	virtual void boil()
	{
		cout << "煮圣水" << endl;
	}

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

	// 倒入杯中
	virtual void pour_in_cup()
	{
		cout << "倒入杯中" << endl;
	}

	// 加入辅料
	virtual void put_something()
	{
		cout << "加入枸杞和菊花" << endl;
	}
};

// 制作函数
void doWork(AbstractDrinking *abs)
{
	abs->make_drink();
	delete abs;
	abs = NULL;
}

int main()
{
	// 制作咖啡
	doWork(new Coffee);
	cout << "==================================" << endl;
	// 制作茶叶
	doWork(new Tea);

	system("pause");
	return 0;
}

七. 虚析构和纯虚析构

① 为什么需要虚析构和纯虚析构
  1. 在使用多态的时候,如果子类中有属性开辟到了堆区,那么父类指针释放的时候无法调用到子类的析构代码.
  2. 可以将父类的析构函数改为虚析构或者纯虚析构.
② 虚析构和纯虚析构的作用
  1. 可以解决父类指针释放子类对象
  2. 如果是纯虚析构,则父类无法实例化对象
③ 虚析构和纯虚析构的必要性

下面这个例子没有用到虚析构和纯虚析构,然后看看会有什么问题?

/*----------------------------------------------------------------
* 项目: Classical Question
* 作者: Fioman
* 邮箱: geym@hengdingzhineng.com
* 时间: 2022/3/22
* 格言: Talk is cheap,show me the code ^_^
//----------------------------------------------------------------*/

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

class Animal
{
public:
	Animal()
	{
		cout << "Animal() 构造函数调用!" << endl;
	}
	virtual void speak() = 0;
	~Animal()
	{
		cout << "Animal() 析构函数被调用!" << endl;
	}
};

class Cat :public Animal
{
public:
	Cat(string name)
	{
		cout << "Cat() 构造函数调用!" << endl;
		// 堆区分配的内存
		mName = new string(name);
	}
	virtual void speak()
	{
		cout << *mName <<  "猫在说话!" << endl;
	}
	~Cat()
	{
		cout << "Cat() 析构函数调用!" << endl;
		if (mName != NULL)
		{
			delete mName;
			mName = NULL;
		}
	}
public:
	string *mName;
};

int main()
{
	Animal *animal = new Cat("汤姆");
	animal->speak();
	delete animal; // 释放内存
	animal = NULL; // 有问题,父类指针不会释放子类的析构函数.所以子类的堆区内存没有被释放.
	system("pause");
	return 0;
}

结果:

解析

  1. 在释放父类指针的时候,只有父类的析构函数被调用.
  2. 子类有变量分配到了堆区,但是内存并没有被释放,引发内存泄漏.

解决方案

  1. 将父类的析构函数定义为虚析构或者是纯虚析构
  2. 子类重写析构函数
/*----------------------------------------------------------------
* 项目: Classical Question
* 作者: Fioman
* 邮箱: geym@hengdingzhineng.com
* 时间: 2022/3/22
* 格言: Talk is cheap,show me the code ^_^
//----------------------------------------------------------------*/

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

class Animal
{
public:
	Animal()
	{
		cout << "Animal() 构造函数调用!" << endl;
	}
	virtual void speak() = 0;
	virtual ~Animal()
	{
		cout << "Animal() 析构函数被调用!" << endl;
	}
};

class Cat :public Animal
{
public:
	Cat(string name)
	{
		cout << "Cat() 构造函数调用!" << endl;
		// 堆区分配的内存
		mName = new string(name);
	}
	virtual void speak()
	{
		cout << *mName <<  "猫在说话!" << endl;
	}
	 virtual ~Cat()
	{
		cout << "Cat() 析构函数调用!" << endl;
		if (mName != NULL)
		{
			delete mName;
			mName = NULL;
		}
	}
public:
	string *mName;
};

int main()
{
	Animal *animal = new Cat("汤姆");
	animal->speak();
	delete animal; // 释放内存
	animal = NULL; // 有问题,父类指针不会释放子类的析构函数.所以子类的堆区内存没有被释放.
	system("pause");
	return 0;
}

结果:

纯虚析构

  1. 纯虚析构在类外也要实现它
  2. 如果一个类有了纯虚析构,则这个类就是抽象类.
Fioman_Hammer
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++职工管理系统（多态）
10-09
可以用来练习C++的继承、多态、抽象类等等，也可以作为课程实验的程序。简单易懂，分文件编写。。。。。。。。。。。。。。。。。。。。。。
C++ 上课/复习ppt多态.pptx
09-30
C++ 上课/复习ppt多态.pptx
C++多态的实现原理
热门推荐
Demons的博客
05-05 3万+
一、多态的概念            多态就是多种形态，C++的多态分为静态多态与动态多态。静态多态就是重载，因为在编译期决议确定，所以称为静态多态。在编译时就可以确定函数地址。动态多态就是通过继承重写基类的虚函数实现的多态，因为实在运行时决议确定，所以称为动态多态。运行时在虚函数表中寻找调用函数的地址。     在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实...
类的多态练习_C++_类的多态练习_
09-29
C++类的多态练习（Class polymorphism exercise）
动态多态的实现和虚析构和纯虚析构（c++）
weixin_67993841的博客
04-23 1143
首先需要明确多态性的用途，是为了接口的最大程度复用，以及其定义： 多态性的定义，可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。多态(polymorphism)，字面意思多种形状。多态分为静态多态和动态多态。 静态多态是通过重载和模板技术实现，在编译的时候确定。 动态多态通过虚函数和继承关系来实现，执行动态绑定，在运行的时候确定。 定义明确，接下来看看最常见的动态多态的实现思路：对于一组相关的数据类型，抽象出它们之间共同的功能集合，在基类中将共同的功
静态多态与动态多态
challenglistic的博客
04-01 1406
静态多态与动态多态
1分钟理解C++静态多态和动态多态的区别
大道至简，求同存异
04-13 1696
1分钟理解C++静态多态和动态多态的区别
面经：静态多态和动态多态的区别？
weixin_42520189的博客
07-02 1115
协变是重写的一种特殊情况，它允许派生类的虚函数返回类型与基类的虚函数返回类型不完全相同，但是保持了兼容性和层次关系。通常，在进行协变时，返回类型应该是基类返回类型的派生类型，也就是更具体或更窄的类型。通过在派生类的函数重写声明中使用相同的函数名称、参数列表，并将返回类型作为基类返回类型的派生类型，可以实现协变。- 通过基类指针或引用调用虚函数，根据指针或引用指向的实际对象的类型，决定调用哪个派生类的方法。- 静态多态在编译时确定调用的函数版本，而动态多态在运行时确定调用的函数版本。
C++/操作系统/计网-基础
m0_59015141的博客
09-25 1370
C++： 1，C和C++区别 (1)C语言是面向过程的程序设计，主要核心为数据结构和算法。C++是面向对象的程序设计 (2)C++包含C语言所有库 (3)C++比C语言变量检测增强 2，C++三大特性 (1)封装：封装隐藏了类的实现细节和成员数据，属性私有化，行为公有化。 (2)继承：子类可以复用父类的方法和成员，实现了代码的复用，提高编码效率 (3)多态：一个接口，多种方法。
C++静态多态与动态多态
路过的熊的博客
06-20 2983
多态按字面的意思就是多种形态，相同的方法调用，但是有不同的实现方式。多态性可以简单地概括为“一个接口，多种方法，实现接口与实现的分离。 C++有两种多态形式：静态多态：也称为编译期间的多态，编译器在编译期间完成的，编译器根据函数实参的类型(可能会进行隐式类型转换)，可推断出要调用那个函数，如果有对应的函数就调用该函数，否则出现编译错误。 静态多态有两种实现方式： 函数重载 函数重载就像是有多种含义的动词。例如：你可以在棒球场为球队助威（root），也可以在地里种植（root）菌类植物。 根据上下文可以知道每
小型员工管理系统_继承_C++_多态_
10-02
企业中包括普通员工、中层管理人员、财务人员、高层管理人员等。每类人员可能具有不同的基本信息，或拥有不同的功能操作。1) 每个员工都具有基本信息（姓名、性别、年龄、职务、工作时间等）但是根据员工类型不同...
CPP.rar_多态 .cpp_继承与多态_继承与多态C++
09-23
本代码中有：“包含与继承”、“虚函数与多态”、“模板”程序例子
动态绑定的多态的实现原理
面包的博客
03-11 2144
嘿嘿，上篇写了多态的一些理解，马不停蹄又去补了多态的实现原理——虚表。我觉得源栗子（原例子)写的简单明了，就直接转过来了，大家一起学习学习。 原文点击打开链接，我稍微精简了一下 1. 用virtual关键字声明的函数叫做虚函数，虚函数肯定是类的成员函数。 2. 存在虚函数的类都有一个一维的虚函数表叫做虚表。类的对象有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。 3.
C++ 多态实现
Hemingway_Hoo的博客
09-12 410
多态 多态的含义为 一个事物的多种形态，在C++程序设计张，多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数。 一般多态分为两种 1）静态多态 也成为编译多态，主要包括参数多态，过载多态和强制多态。 参数多态：采用参数化模板，通过给出不同的类型参数，使的一个结构有多种类型。如C++语言中的函数模板和类模板。如 C++语言中的函数模板和类模...
多态浅析（静态多态，动态多态）
ZHOUJIforever的博客
07-19 2389
多态 多态分为动态多态和静态多态。 静态多态：在运行前就决定函数调用的地址，也就是地址早绑定。 静态多态包括了：函数重载，运算符重载，和重定义。 分别阐述一下： 函数重载首先在同一个作用域当中，函数的名字相同，但是函数的参数不同（类型，个数，顺序） void func(void) { cout<<"good! 没有参数"<<endl; } void func(int val) { cout<<"good! 一个int类型参数"<<endl; }
说说多态，多态有几种类型，怎么实现
weixin_46716100的博客
08-30 757
由于该函数是虚函数且派生类进行了重写，因此会根据实际指向的对象类型来动态选择调用哪个函数。函数重载允许在同一个作用域内定义多个名称相同但参数类型或参数个数不同的函数，在编译时根据调用时传递的参数类型或个数来确定具体调用哪个函数。在基类中声明虚函数，并在派生类中进行重写，从而使得在通过基类指针或引用调用虚函数时，根据实际指向的派生类对象来动态选择调用哪个函数。3、通过基类指针或引用调用虚函数，系统会根据实际指向的派生类对象来动态选择调用哪个函数。静态多态（编译时多态）和动态多态（运行时多态）。
静态多态和动态多态的区别
weixin_45027171的博客
12-30 6653
#include <iostream> using namespace std; class A { public: virtual void function() { cout << "I am A" << endl; } }; class B :public A { public: void function() { cout << "I used to be A but now I am B" << endl; } void fun
C++静态多态与动态多态的实现原理剖析
geek！
09-22 1203
静态多态主要借助**模板和重载**。在编译期间，编译器通过类型来实例化模板或者选择合适的重载。因此，**静态多态在编译期间完成**。
C++（引用）
最新发布
weixin_61218382的博客
05-06 308
给变量其别名数据类型 &别名 = 原名。
shared_ptr多态
04-12
shared_ptr是C++中的智能指针，用于管理动态分配的内存资源。它可以在多个指针之间共享所有权，并且可以自动释放内存资源，避免内存泄漏。 在多态方面，shared_ptr可以用于实现基类指针指向派生类对象的情况，从而实现多态性。具体实现方式如下： 1. 首先，需要定义一个基类和一个或多个派生类。基类应该包含虚函数，以便在派生类中进行重写。 2. 使用shared_ptr来管理对象的内存分配和释放。可以将派生类对象的指针赋值给shared_ptr<基类类型>，这样就可以实现基类指针指向派生类对象的效果。 3. 当使用shared_ptr进行对象访问时，会根据对象的实际类型调用相应的虚函数，实现多态性。 使用shared_ptr多态的好处是可以避免手动管理内存资源的麻烦，并且能够确保内存资源的正确释放，提高代码的可靠性和安全性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值