【C++ | 虚函数】虚函数详解 及 例子代码演示(包含虚函数使用、动态绑定、虚函数表、虚表指针)

于 2024-07-13 14:34:09 发布
阅读量1.4k 收藏 49
点赞数 29
分类专栏： C++知识体系 文章标签： c++ 虚函数 虚表指针 虚函数表 动态绑定
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wkd_007/article/details/140316339
版权

😁博客主页😁：🚀https://blog.csdn.net/wkd_007🚀
🤑博客内容🤑：🍭嵌入式开发、Linux、C语言、C++、数据结构、音视频🍭
🤣本文内容🤣：🍭介绍C++的虚函数 🍭
😎金句分享😎：🍭你不能选择最好的，但最好的会来选择你——泰戈尔🍭
⏰发布时间⏰：2024-07-13 14:33:55

本文未经允许，不得转发！！！

目录


在这里插入图片描述

🎄一、什么是虚函数？为什么需要虚函数？

定义：虚函数就是在函数声明时使用关键字virtual修饰的成员函数。其格式一般如下：

class CAnimal{
	virtual void eat();	// 声明了虚函数 eat()
}

为什么需要虚函数？

在C++中使用虚函数的主要目的是实现多态。多态是多种形态的意思，也就是同一个方法在派生类和基类中的行为是不同的。

C++怎样通过虚函数实现多态的呢？一般情况下，通过指针或引用调用一个类成员函数时，程序会 根据引用类型或指针类型 选择对应类的成员函数，如果被调用的成员函数是虚函数的话，则程序将根据 引用或指针指向的对象 的类型来选择方法。

下面用代码演示基类指针调用 正常函数 和 虚函数 的区别：

// g++ 23_Virtual.cpp 
#include <iostream>

using namespace std;

class CAnimal{
public:
	CAnimal(){
		cout << "Calling CAnimal(): this=" << this << endl;
	}
	void eat(){
		cout << "Animal eat" << endl;
	}
	virtual void run(){
		cout << "Animal run" << endl;
	}
	
private:
};


class CDog : public CAnimal{
public:
	CDog(){
		cout << "Calling CDog(), this=" << this << endl;
	}
	void eat(){		// 重写了基类的eat(),基类的会隐藏
		cout << "Dog eat" << endl;
	}
	void run(){
		cout << "Dog run" << endl;
	}
};

int main ()
{
	CAnimal animal;
	CDog dog;
	
	CAnimal* pAnimal = &animal;	// 基类指针指向基类对象
	pAnimal->eat();	// 调用非虚函数，按照指针类型调用，打印 Animal eat
	pAnimal->run();	// 调用虚函数，按照对象类型调用，打印 Animal run
	cout << endl;
	
	pAnimal = &dog;	// 基类指针指向派生类对象
	pAnimal->eat();	// 调用非虚函数，按照指针类型调用，Animal eat
	pAnimal->run();	// 调用虚函数，按照对象类型调用，打印 Dog run
	cout << endl;
	
	return 0;
}

运行结果如下：
在这里插入图片描述

在这里插入图片描述

🎄二、静态绑定、动态绑定

绑定(binding)：编译器将源代码中的函数调用解释为执行特定的函数代码块被称为函数名绑定(binding)。

在 C 语言中，函数名绑定非常简单，因为每个函数名都对应一个不同的函数。 在 C++ 中，由于重载函数的出现，函数名绑定变得复杂，编译器必须査看函数参数以及函数名才能确定使用哪个函数。编译器可以在编译期间完成这样的函数名绑定。但是虚函数的出现使编译器无法在编译期间知道调用的是哪个函数，必须在运行时才完成函数名绑定。

静态绑定(binding)：在编译期间就可以完成的函数名绑定。
动态绑定(binding)：在运行期间才可以完成的函数名绑定。

当 我 们 使 用 基 类 的 引 用 或 指 针 调 用 基 类 中 定 义 的 一 个 函 数 时 ， 我 们 并 不 知 道 该 函 数 真 正 作 用 的 对 象 是 什 么 类 型 ， 因 为 它 可 能 是 一 个 基 类 的 对 象 也 可 能 是 一 个 派 生 类 的 对 象。 如 果 该 函 数 是 虚 函 数， 则 直 到 运 行 时 才 会 决 定 到 底 执 行 哪 个 版 本， 判 断 的 依 据 是 引 用 或 指 针 所 綁 定 的 对 象 的 真 实 类 型

当且仅当对通过指针或引用调用虚函数时，才会在运行时解析该调用，也只有在这种情况下对象的动态类型才有可能与静态类型不同。

之前总是不理解一点，我在定义基类指针或引用时，明明已经指明的对象了，为什么它需要在运行时才知道呢？那是因为考虑少了。如果当基类指针或引用作为函数参数使用，没运行时是不清楚传入的是基类对象或子类对象的。又或者从输入根据条件去创建对象，也是无法事先知道基类指针或引用指向哪个对象的。下面代码演示C++的动态绑定：

// g++ 23_Dynamic_binding.cpp -std=c++11
#include <iostream>
using namespace std;

class CAnimal{
public:
	virtual void run(){
		cout << "Animal run" << endl;
	}
};

class CDog : public CAnimal{
public:
	virtual void run() override{
		cout << "Dog run" << endl;
	}
};

int main ()
{
	const int OBJ_NUM = 4;
	CAnimal *pAnimal[OBJ_NUM];	// 基类指针数组，用于管理对象
	
	// 程序运行后，根据输入类型创建对象
	char kind;		// 用于获取类型
	for(int i=0; i<OBJ_NUM; i++)
	{
		cout << "请输入要创建的对象：1表示CAnimal, 2表示CDog" << endl;
		while(cin >> kind && (kind != '1' && kind != '2'))
			cout << "请输入1或2" << endl;
		if(kind == '1')
			pAnimal[i] = new CAnimal();
		else
			pAnimal[i] = new CDog();
	}
	cout << endl;
	
	// 按照实际的对象打印
	for(int i=0; i<OBJ_NUM; i++)
	{
		pAnimal[i]->run();
	}
	
	for(int i=0; i<OBJ_NUM; i++)
	{
		delete pAnimal[i];	// 释放对象
	}
	return 0;
}

运行结果如下：
在这里插入图片描述

在这里插入图片描述

🎄三、虚函数的使用

虚函数一定是在 继承的前提下 才有用的，如果定义了一个类，它不会被继承，那么这个类定义虚函数也没用。
虚函数一定是在 基类的指针或引用 去调用时，才会按照实际对象类型去动态绑定的。

✨3.1 虚函数在基类的定义

在基类定义虚函数时，需要注意下面几点：

  1. 所有虚函数都必须有定义。因为直到运行时才知道调用哪个虚函数，这样做避免出现问题。
  2. 如果某个函数的行为在派生类会存在不同实现，则可以考虑设置成虚函数，例如：CAnimal类的eat方法就可能与其派生类CDog的 eat方法不同实现。
  3. 如果不需要在派生类中重新定义基类的函数，则不应该将其设置为虚函数，节省开销。例如下面例子的setName函数。
  4. 一旦某个函数在基类被声明成虚函数，则在所有派生类中它都是虚函数。
  5. 构造函数不能声明为虚函数。
  6. 基类的析构函数一般声明为虚函数。这样做是为了确保释放派生对象时，按正确的顺序调用析构函数。如果析构函数不是虚的， 则将只调用对应于指针类型的析构函数。如果析构函数是虚的，将调用相应对象类型的析构函数。
  7. 关键字virtual只用于类声明的函数原型中，不出现在定义的时候。

🌰举例子：

// g++ 23_Virtual_usage.cpp 
#include <iostream>
#include <string.h>

using namespace std;

class CAnimal{
public:
	//virtual CAnimal(){ 	// 5、构造函数不能设置虚函数
	CAnimal(){
		cout << "Calling CAnimal(): this=" << this << endl;
	}
	virtual void eat(){	// 2、派生类的eat()可能不同实现，设置成虚函数
		cout << "Animal eat" << endl;
	}
	void setName(char *name)	// 3、不需要在派生类重写的函数，不设置成虚函数
	{
		strncpy(m_name, name, sizeof(m_name));
	}
	virtual ~CAnimal(){	// 6、基类的析构函数声明为虚函数
		cout << "~CAnimal" << endl;
	}
private:
	char m_name[64];
};


class CDog : public CAnimal{
public:
	CDog(){
		cout << "Calling CDog(), this=" << this << endl;
	}
	virtual void eat(){		// 重写了基类的eat()
		cout << "Dog eat bones" << endl;
	}
	~CDog(){
		cout << "~CDog" << endl;
	}
};

int main ()
{
	CAnimal* pAnimal = new CAnimal();	// 基类指针指向基类对象
	pAnimal->eat();
	delete pAnimal;
	pAnimal = NULL;
	cout << endl;
	
	pAnimal = new CDog();	// 基类指针指向派生类对象
	pAnimal->eat();
	delete pAnimal;
	pAnimal = NULL;
	cout << endl;
	
	return 0;
}

运行结果如下，下面运行了两次，第一次是基类析构函数没声明为虚函数的。
在这里插入图片描述

✨3.2 虚函数在派生类的使用

基类定义的虚函数，如果派生类有不同的实现，需要重写。

派生类使用虚函数注意几点：

  1. 一旦某个函数在基类被声明成虚函数，则在所有派生类中它都是虚函数。
  2. 如果派生类重新定义基类的虚函数，最好加上关键字virtual，这样使代码更容易读。不加virtual的话，也是虚函数。
  3. 重写基类的虚函数时，需要保证 函数名，参数列表，const属性 都与基类的虚函数声明一致。
    class CAnimal{
public:
    virtual void eat(int x) const; // 虚函数
};
 
class CDog: public CAnimal{
public:
    virtual void Eat(int x); // e 写成 E，函数名不一致，新的虚函数 
    virtual void eat(short x); // 参数列表不一样，新的虚函数 
    virtual void eat(int x); // const 属性不一样，新的虚函数 
    virtual void eat(int x) const; // 函数名，参数列表，const属性都一致，重写了基类的虚函数 
}
  4. 重写基类虚函数时，返回值类型也需要一致，否则会编译报错。下面这个情况除外，如果基类虚函数返回值类型是基类指针或引用时，在派生类重写时返回值类型可以在派生类指针或引用。
    class CAnimal{
public:
   virtual CAnimal *run(int a) const;
};

class CDog: public CAnimal{
public:
   virtual CDog *run(int a) const;	// 重写了基类的 run ,但返回值为 CDog*
}

🌰完整例子：

// g++ 23_Virtual_usage2.cpp 
#include <iostream>
#include <string.h>

using namespace std;

class CAnimal{
public:
	CAnimal(){
		cout << "Calling CAnimal(): this=" << this << endl;
	}
	virtual void eat(int a) const{
		cout << "Animal eat" << endl;
	}
	virtual CAnimal *run(int a) const{
		cout << "Animal run" << endl;
		return new CAnimal();
	}
	virtual ~CAnimal(){
		cout << "~CAnimal" << endl;
	}

};


class CDog : public CAnimal{
public:
	CDog(){
		cout << "Calling CDog(), this=" << this << endl;
	}
	
	virtual void Eat(int x){};		// e 写成 E，函数名不一致，新的虚函数 
	virtual void eat(short x){};	// 参数列表不一样，新的虚函数 
	virtual void eat(int x){};		// const 属性不一样，新的虚函数 
	virtual void eat(int a) const{		// 重写了基类的eat()
		cout << "Dog eat bones" << endl;
	}
	virtual CDog *run(int a) const{	// 重写了基类的 run ,但返回值为 CDog*
		cout << "CDog run" << endl;
		return new CDog();
	}
	~CDog(){
		cout << "~CDog" << endl;
	}
};

int main ()
{
	CAnimal* pAnimal = new CAnimal();	// 基类指针指向基类对象
	CAnimal* pRun = pAnimal->run(1);
	pAnimal->eat(1);
	delete pAnimal;
	pAnimal = NULL;
	cout << endl;
	delete pRun;
	pRun = NULL;
	cout << endl;
	
	pAnimal = new CDog();	// 基类指针指向派生类对象
	pRun = pAnimal->run(1);
	pAnimal->eat(1);
	delete pAnimal;
	pAnimal = NULL;
	cout << endl;
	delete pRun;
	pRun = NULL;
	cout << endl;
	
	return 0;
}

运行结果：
在这里插入图片描述

✨3.3 final 和 override 说明符

由于派生类重写虚函数时需要 函数名，参数列表，const属性 都一致才行，这样容易导致写错。C++11提供了两个说明符 final 和 override 来帮助我们更好地使用虚函数。

  • final 说明符：如果基类已经把函数定义成 final 了， 则之后任何尝试覆盖该函数的操作都将引发错误：
    class CAnimal{
public:
	virtual void finlaFun(int a) const final; // 指定为final，不允许被重写
};
class CDog : public CAnimal{
public:
	virtual void finlaFun(int a) const{}	// 基类指定为final了，重写会报错
};
  • override 说明符：可以告诉编译器，我们写的这个函数是为了重写基类的虚函数，如果 函数名，参数列表，const属性，返回值 这些不一致，就给我报错。在3.2的例子中，我们声明的虚函数如果和基类不一致会成为新的虚函数，加上override之后，如果不构成重写就会报错
    class CAnimal{
public:
    virtual void eat(int x) const; // 虚函数
};
 
class CDog: public CAnimal{
public:
    virtual void Eat(int x)override{};		// e 写成 E，函数名不一致，报错
	virtual void eat(short x)override{};	// 参数列表不一样，报错
	virtual void eat(int x)override{};		// const 属性不一样，报错
	virtual void eat(int a) const override{		// 重写了基类的eat()
		cout << "Dog eat bones" << endl;
	}
}

🌰完整例子：

// g++ 23_Virtual_usage3.cpp -std=c++11
#include <iostream>
#include <string.h>

using namespace std;
#define DEBUG 1
class CAnimal{
public:
	CAnimal(){
		cout << "Calling CAnimal(): this=" << this << endl;
	}
	virtual void finlaFun(int a) const final{	// 指定为final，不允许被重写
		cout << "Animal finlaFun" << endl;
	}
	virtual void eat(int a) const{
		cout << "Animal eat" << endl;
	}
	virtual CAnimal *run(int a) const{
		cout << "Animal run" << endl;
		return new CAnimal();
	}
	virtual ~CAnimal(){
		cout << "~CAnimal" << endl;
	}
};


class CDog : public CAnimal{
public:
	CDog(){
		cout << "Calling CDog(), this=" << this << endl;
	}
#if DEBUG
	virtual void finlaFun(int a) const{}	// 基类指定为final了，重写会报错
	
	virtual void Eat(int x)override{};		// e 写成 E，函数名不一致，报错
	virtual void eat(short x)override{};	// 参数列表不一样，报错
	virtual void eat(int x)override{};		// const 属性不一样，报错
#endif
	virtual void eat(int a) const override{		// 重写了基类的eat()
		cout << "Dog eat bones" << endl;
	}
	virtual CAnimal *run(int a) const override{// 重写了基类的 run ,但返回值为 CDog*
		cout << "CDog run" << endl;
		return new CDog();
	}
	~CDog(){
		cout << "~CDog" << endl;
	}
};

int main ()
{
	CAnimal* pAnimal = new CAnimal();	// 基类指针指向基类对象
	delete pAnimal;
	pAnimal = NULL;
	cout << endl;
	
	pAnimal = new CDog();	// 基类指针指向派生类对象
	delete pAnimal;
	pAnimal = NULL;
	cout << endl;
	
	return 0;
}

编译上面例子时，需要添加 -std=c++11 让编译器支持C++11标准，编译报错结果如下，想编译通过需要把宏DEBUG的值改为0：
在这里插入图片描述

在这里插入图片描述

🎄四、虚函数表、虚表指针

这个小节介绍虚函数的工作原理。

✨4.1 虚表指针

通常， 编译器处理虚函数的方法是：给每个对象添加一个隐藏成员。隐藏成员中保存了一个指向函数地址数组的指针。这个函数地址数组被成为虚函数表，而这个隐藏成员被成为虚表指针(在32位系统占用4个字节，64位系统占用8个字节)。所以，当一个类存在虚函数，那么它就会多占用一个指针大小的内存。这个指针会存在类对象的最前面。下面例子可以证明对象中存在一个虚表指针：

// g++ 23_Virtual_Point.cpp
#include <iostream>
using namespace std;

class CAnimal_NULL{	// 空类
};

class CAnimal{		// 基类，有一个虚函数
public:
	virtual void eat(){}
};

class CDog : public CAnimal{// 派生类，继承了基类的虚函数
};

int main ()
{
	CAnimal_NULL animal_null;
	CAnimal animal;
	CDog dog;
	cout << sizeof(animal_null) << endl;
	cout << sizeof(animal) << endl;
	cout << sizeof(dog) << endl;
}

运行结果，空类的大小是1，只定义了一个虚函数，类大小就变成8了，刚好是一个64位指针大小。
在这里插入图片描述

✨4.2 虚函数表

当基类定义了虚函数，基类对象就会将这些虚函数地址都存放到一个函数地址数组中(虚函数表)，然后将这个数组的地址存放到对象的开始位置。

派生类对象的开始位置也会有一个虚表指针，指向一个独立的虚函数表，如果派生类重写(重新定义)了基类的虚函数，则会将重写的函数地址替换掉从基类继承的虚函数地址。

下面用代码演示类对象的虚函数表，甚至可以直接通过函数地址调用类的虚函数：

// g++ 23_Virtual_FunTable.cpp -std=c++11
#include <iostream>
using namespace std;

class CAnimal{
public:
	virtual void eat(){
		cout << "Animal eat" << endl;
	}
	virtual void run(){
		cout << "Animal run" << endl;
	}
private:
	char m_name[64];
};

class CDog : public CAnimal{
public:
	virtual void run() override{	// 重写，会使用新的虚函数地址
		cout << "Dog run" << endl;
	}
	virtual void jump(){
		cout << "Dog jump" << endl;
	}
private:
	int hair_color;
};
 
typedef void(*PFUN)(void);	// 定义函数指针类型
int main ()
{
	CAnimal animal;
	CDog dog;
	
	// 获取虚表指针，类对象第一个指针大小的内存里的值
	unsigned long* vptr_animal = (unsigned long*)(*((unsigned long*)(&animal)));
	unsigned long* vptr_dog = (unsigned long*)*(unsigned long*)&dog;
	
	// 打印虚函数表各个虚函数地址
	cout << "虚表指针：" << vptr_animal << endl;
	for(int i=0; i<2; i++)
	{
		cout << "animal虚函数表-第 " << i+1 << " 个虚函数地址：" << *vptr_animal << endl;
		PFUN pfun = (PFUN)*vptr_animal;
		pfun();	// 使用函数地址调用类函数
		vptr_animal++;
	}
	
	cout << endl;
	
	cout << "虚表指针：" << vptr_dog << endl;
	for(int i=0; i<3; i++)
	{
		cout << "dog虚函数表-第 " << i+1 << " 个虚函数地址：" << *vptr_dog << endl;
		PFUN pfun = (PFUN)*vptr_dog;
		pfun();	// 使用函数地址调用类函数
		vptr_dog++;
	}
}

运行结果如下：
在这里插入图片描述
可以结合下图去理解代码：

在这里插入图片描述

在这里插入图片描述

🎄五、总结

👉本文介绍了C++的虚函数，包括虚函数的定义、重写，动态绑定、虚函数表、虚表指针等内容。

在这里插入图片描述
如果文章有帮助的话，点赞👍、收藏⭐，支持一波，谢谢 😁😁😁

参考：
《C++ primer plus》
《C++ primer》
C++虚函数详解

wkd_007
关注
  • 29
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 25
    评论
专栏目录
C++虚函数
mxy568767179的博客
05-15 1892
C++中动态多态要靠虚函数来实现，下面我们来详细的说一下虚函数的机制 虚函数表 C++中的虚函数是通过一张虚函数表中实现的，在虚函数表中存储着每个虚函数的地址。那么编译器是怎么访问虚函数表的呢，下面我们看这样一段代码 class Shape{ public: void getArea() { cout<<"Shape"<<endl; } }; int main() { Shape sss; cout<<sizeof(s
C++对象内存分布详解(包括字节对齐和虚函数表)
12-31
C++对象的内存分布和虚函数表注意，对象中保存的是虚函数表指针，而不是虚函数表，虚函数表在编译阶段就已经生成，同类的不同对象中的虚函数指针指向同一个虚函数表，不同类对象的虚函数指针指向不同虚函数表。...
C++——虚函数和纯虚函数、抽象类、虚析构和纯虚析构
qq_42106610的博客
06-17 7077
C++虚函数、纯虚函数、虚析构、纯虚析构，其中虚函数的原理为重点
虚函数，虚指针，虚表，虚析构函数和多态
weixin_40026739的博客
01-31 1442
而且，只要它是最后的构造函数调用，那么在这个对象的生命期内，VPTR将保持被初始化为指向这个VTABLE, 但如果接着还有一个更晚派生的构造函数被调用，这个构造函数又将设置VPTR指向它的 VTABLE，等.直到最后的构造函数结束。多态，就是存在虚函数的基类和存在一个或者多个基于该基类（并且实现了该基类的虚函数）的派生类，当一个基类指针指向不同的派生类时，通过基类指针调用虚函数，会有不同的实现，从而实现虚函数的多态性质。当使用基类指针或引用调用虚函数时，实际调用的是指向派生类的虚函数表的相应虚函数。
C++迈向精通：当我尝试修改虚函数表
最新发布
Royi的学习博客
06-13 558
本文介绍了一种虚函数表的查看与替换方式
C++ 虚函数实例
weixin_30402085的博客
06-07 553
#include <iostream> using namespace std; //线 class Line { public: Line(float len); virtual float area() = 0; virtual float volume() = 0; protected: ...
十个例子让你完全搞懂 C++ 的虚函数（不懂来找我）
weixin_34326558的博客
08-12 331
Author： bakari  Date: 2012.4.8 装载引用请注明出处：http://www.cnblogs.com/bakari/archive/2012/08/12/2635369.html   谢谢！ 虚函数是C++中非常重要的一个概念，它最大的好处是能够触发动态绑定。C++中的函数默认不使用动态绑定，要触发动态绑定，必须满足 两个条件： 第一，只有指定为虚函数的成员函数才能...
C++中的虚函数（一）
zheng80037的专栏
05-30 645
C++中的虚函数（一）作者：aber     虽然很难找到一本不讨论多态性的C++书籍或杂志，但是，大多数这类讨论使多态性和C++虚函数的使用看起来很难。我打算在这篇文章中通过从几个方面和结合一些例子使读者理解在C++中的虚函数实现技术。说明一点，写这篇文章只是想和大家交流学习经验因为本人学识浅薄，难免有一些错误和不足，希望大家批评和指正，在此深表感谢！ 一、 基本概念    首先
虚函数
Do Not Exist
06-25 438
定义 定义：在某基类中声明为 virtual 并在一个或多个派生类中被重新定 义的成员函数[1] 语法：virtual 函数返回类型 函数名（参数表） {函数体} 用途：实现多态性，通过指向派生类的基类指针，访问派生类中同名覆盖成员函数 虚函数必须是基类的非静态成员函数，其访问权限可以是private或protected或public，在基类的类定义中定义虚函数的一般形式： class基
C++ 类中有虚函数(虚函数表)时 内存分布详解
08-31
这是因为编译器会根据对象实例中的虚函数表指针找到对应的虚函数地址。 考虑以下例子： ```cpp class Base { public: virtual void f() { cout ; } virtual void g() { cout ; } virtual void h() { cout ; } }...
C++ 基础教程之虚函数实例代码详解
08-25
C++ 虚函数实例代码详解 本文将详细介绍 C++ 中虚函数的概念、定义和使用方法，并提供实例代码来帮助读者更好地理解虚函数的实现机制。 虚函数的定义： 虚函数是指在基类的成员函数前加关键字 virtual，并在一个或...
虚函数简单示例
07-15
虚函数简单示例
详解C++编程中的虚函数
09-03
3. **虚函数表**：C++实现虚函数调用依赖于虚函数表（Vtable），每个包含虚函数的类都有一个虚函数表，记录了类中虚函数的地址。 4. **构造函数与析构函数**：C++标准规定构造函数不能是虚函数，但析构函数默认是虚...
详解C++虚函数的工作原理
12-17
虚函数表的工作方式如下：当通过基类指针或引用调用虚函数时，编译器不会直接生成调用函数的代码，而是生成一条跳转指令，这个指令会查找对象实例中的虚函数表指针，然后根据指针找到相应的虚函数地址并执行。...
c++虚函数经典例子演示
weixin_30565327的博客
11-30 271
c++博大精深，封装，继承，多态是c++的三大特征，c++很强大，但是强大的东西理解起来就是要比不强大的难一点，所以现在看看 c++的多态： 多态条件： 1.必须是公有继承。 2.必须是虚函数 一个好的程序要对修改封闭，对扩展开放，虚函数就能很好的解决这个问题， 基类的指针指向子类的对象并调用子类的同名函数，要实现这种效果，就得用虚函数 关键字:virtual 虚函数的注意点： ...
C ++ 虚函数 （转）
weixin_33734785的博客
08-20 80
第一节、一道简单的虚函数的面试题题目要求：写出下面程序的运行结果?       1、当上述程序中的函数p()不是虚函数，那么程序的运行结果是如何?即如下代码所示： class A{public: void p() {  cout &lt;&lt; "A" &lt;&lt; endl; }}; class B : public A{public: void p() {  cout &lt;&lt;...
c++ 虚函数
Meteor的笔记
11-14 1445
c++ 虚函数
C++中的虚函数(virtual function)
木兰当户
04-17 516
1.简介     虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。假设我们有下面的类层次： class A { public:     virtual void foo() { cout }; class B: public A { public:     virtual void
C++ 虚函数相关，从头到尾捋一遍
anrui0096的博客
04-04 1153
众所周知，C++虚函数是一大难点，也是面试过程中必考部分。此次，从虚函数的相关概念、虚函数表、纯虚函数、再到虚继承等等跟虚函数相关部分，做一个比较细致的整理和复习。 虚函数 OOP的核心思想是多态性(polymorphism)。把具有继承关系的多个类型称为多态类型。引用或指针的静态类型与动态类型不同这一事实正是C++实现多态性的根本。 C++ 的多态实现即是通过虚函数。在C++中，基...
虚函数的使用有什么好处
06-01
虚函数是C++中的一种特殊类型的函数，它可以在基类中声明为虚函数，在派生类中重写该函数，以实现多态性。而多态性是面向对象程序设计中非常重要的一个特性，它可以使得程序更加灵活、可扩展，并且能够使用更加高效的代码来处理问题。 使用虚函数的好处包括： 1. 实现多态性：虚函数使得程序可以选择在运行时调用哪个函数，从而实现多态性，这使得程序更加灵活、可扩展。 2. 简化代码：使用虚函数可以简化代码，减少重复的代码，因为虚函数只需要在基类中声明一次，就可以在所有的派生类中重写。 3. 提高性能：虚函数使用动态绑定来实现多态性，这比静态绑定更加高效，因为在运行时进行绑定，可以根据实际的对象类型来进行调用，而不是在编译时就决定好调用哪个函数。 总之，虚函数是C++中非常重要的一个特性，它可以使得程序更加灵活、可扩展，并且能够使用更加高效的代码来处理问题。
评论 25
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wkd_007

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

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

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

打赏作者

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

抵扣说明：

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

余额充值