怎么用虚函数实现呢？

虚函数联系到多态，多态联系到继承。所以本文中都是在继承层次上做文章。没了继承，什么都没得谈。

成都创新互联于2013年开始，先为樊城等服务建站，樊城等地企业，进行企业商务咨询服务。为樊城企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

下面是对C++的虚函数这玩意儿的理解。

一， 什么是虚函数（如果不知道虚函数为何物，但有急切的想知道，那你就应该从这里开始）

简单地说，那些被virtual关键字修饰的成员函数，就是虚函数。虚函数的作用，用专业术语来解释就是实现多态性（Polymorphism），多态性是将接口与实现进行分离；用形象的语言来解释就是实现以共同的方法，但因个体差异而采用不同的策略。下面来看一段简单的代码

class A{

public:

void print(){ cout”This is A”endl;}

};

class B:public A{

public:

void print(){ cout”This is B”endl;}

};

int main(){ //为了在以后便于区分，我这段main()代码叫做main1

A a;

B b;

a.print();

b.print();

}

通过class A和class B的print()这个接口，可以看出这两个class因个体的差异而采用了不同的策略，输出的结果也是我们预料中的，分别是This is A和This is B。但这是否真正做到了多态性呢？No，多态还有个关键之处就是一切用指向基类的指针或引用来操作对象。那现在就把main()处的代码改一改。

int main(){ //main2

A a;

B b;

A* p1=a;

A* p2=b;

p1-print();

p2-print();

}

运行一下看看结果，哟呵，蓦然回首，结果却是两个This is A。问题来了，p2明明指向的是class B的对象但却是调用的class A的print()函数，这不是我们所期望的结果，那么解决这个问题就需要用到虚函数

class A{

public:

virtual void print(){ cout”This is A”endl;} //现在成了虚函数了

};

class B:public A{

public:

void print(){ cout”This is B”endl;} //这里需要在前面加上关键字virtual吗？

};

毫无疑问，class A的成员函数print()已经成了虚函数，那么class B的print()成了虚函数了吗？回答是Yes，我们只需在把基类的成员函数设为virtual，其派生类的相应的函数也会自动变为虚函数。所以，class B的print()也成了虚函数。那么对于在派生类的相应函数前是否需要用virtual关键字修饰，那就是你自己的问题了。

现在重新运行main2的代码，这样输出的结果就是This is A和This is B了。

现在来消化一下，我作个简单的总结，指向基类的指针在操作它的多态类对象时，会根据不同的类对象，调用其相应的函数，这个函数就是虚函数。

二， 虚函数是如何做到的（如果你没有看过《Inside The C++ Object Model》这本书，但又急切想知道，那你就应该从这里开始）

虚函数是如何做到因对象的不同而调用其相应的函数的呢？现在我们就来剖析虚函数。我们先定义两个类

class A{ //虚函数示例代码

public:

virtual void fun(){cout1endl;}

virtual void fun2(){cout2endl;}

};

class B:public A{

public:

void fun(){cout3endl;}

void fun2(){cout4endl;}

};

由于这两个类中有虚函数存在，所以编译器就会为他们两个分别插入一段你不知道的数据，并为他们分别创建一个表。那段数据叫做vptr指针，指向那个表。那个表叫做vtbl，每个类都有自己的vtbl，vtbl的作用就是保存自己类中虚函数的地址，我们可以把vtbl形象地看成一个数组，这个数组的每个元素存放的就是虚函数的地址，请看图

通过上图，可以看到这两个vtbl分别为class A和class B服务。现在有了这个模型之后，我们来分析下面的代码

A *p=new A;

p-fun();

毫无疑问，调用了A::fun()，但是A::fun()是如何被调用的呢？它像普通函数那样直接跳转到函数的代码处吗？No，其实是这样的，首先是取出vptr的值，这个值就是vtbl的地址，再根据这个值来到vtbl这里，由于调用的函数A::fun()是第一个虚函数，所以取出vtbl第一个slot里的值，这个值就是A::fun()的地址了，最后调用这个函数。现在我们可以看出来了，只要vptr不同，指向的vtbl就不同，而不同的vtbl里装着对应类的虚函数地址，所以这样虚函数就可以完成它的任务。

而对于class A和class B来说，他们的vptr指针存放在何处呢？其实这个指针就放在他们各自的实例对象里。由于class A和class B都没有数据成员，所以他们的实例对象里就只有一个vptr指针。通过上面的分析，现在我们来实作一段代码，来描述这个带有虚函数的类的简单模型。

#includeiostream

using namespace std;

//将上面“虚函数示例代码”添加在这里

int main(){

void (*fun)(A*);

A *p=new B;

long lVptrAddr;

memcpy(lVptrAddr,p,4);

memcpy(fun,reinterpret_castlong*(lVptrAddr),4);

fun(p);

delete p;

system("pause");

}

用VC或Dev-C++编译运行一下，看看结果是不是输出3，如果不是，那么太阳明天肯定是从西边出来。现在一步一步开始分析

void (*fun)(A*); 这段定义了一个函数指针名字叫做fun，而且有一个A*类型的参数，这个函数指针待会儿用来保存从vtbl里取出的函数地址

A* p=new B; 这个我不太了解，算了，不解释这个了

long lVptrAddr; 这个long类型的变量待会儿用来保存vptr的值

memcpy(lVptrAddr,p,4); 前面说了，他们的实例对象里只有vptr指针，所以我们就放心大胆地把p所指的4bytes内存里的东西复制到lVptrAddr中，所以复制出来的4bytes内容就是vptr的值，即vtbl的地址

现在有了vtbl的地址了，那么我们现在就取出vtbl第一个slot里的内容

memcpy(fun,reinterpret_castlong*(lVptrAddr),4); 取出vtbl第一个slot里的内容，并存放在函数指针fun里。需要注意的是lVptrAddr里面是vtbl的地址，但lVptrAddr不是指针，所以我们要把它先转变成指针类型

fun(p); 这里就调用了刚才取出的函数地址里的函数，也就是调用了B::fun()这个函数，也许你发现了为什么会有参数p,其实类成员函数调用时，会有个this指针，这个p就是那个this指针，只是在一般的调用中编译器自动帮你处理了而已，而在这里则需要自己处理。

delete p;和system("pause"); 这个我不太了解，算了，不解释这个了

如果调用B::fun2()怎么办？那就取出vtbl的第二个slot里的值就行了

memcpy(fun,reinterpret_castlong*(lVptrAddr+4),4); 为什么是加4呢？因为一个指针的长度是4bytes，所以加4。或者memcpy(fun,reinterpret_castlong*(lVptrAddr)+1,4); 这更符合数组的用法，因为lVptrAddr被转成了long*型别，所以+1就是往后移sizeof(long)的长度

三， 以一段代码开始

#includeiostream

using namespace std;

class A{ //虚函数示例代码2

public:

virtual void fun(){ cout"A::fun"endl;}

virtual void fun2(){cout"A::fun2"endl;}

};

class B:public A{

public:

void fun(){ cout"B::fun"endl;}

void fun2(){ cout"B::fun2"endl;}

}; //end//虚函数示例代码2

int main(){

void (A::*fun)(); //定义一个函数指针

A *p=new B;

fun=A::fun;

(p-*fun)();

fun = A::fun2;

(p-*fun)();

delete p;

system("pause");

}

你能估算出输出结果吗？如果你估算出的结果是A::fun和A::fun2，呵呵，恭喜恭喜，你中圈套了。其实真正的结果是B::fun和B::fun2，如果你想不通就接着往下看。给个提示，A::fun和A::fun2是真正获得了虚函数的地址吗？

首先我们回到第二部分，通过段实作代码，得到一个“通用”的获得虚函数地址的方法

#includeiostream

using namespace std;

//将上面“虚函数示例代码2”添加在这里

void CallVirtualFun(void* pThis,int index=0){

void (*funptr)(void*);

long lVptrAddr;

memcpy(lVptrAddr,pThis,4);

memcpy(funptr,reinterpret_castlong*(lVptrAddr)+index,4);

funptr(pThis); //调用

}

int main(){

A* p=new B;

CallVirtualFun(p); //调用虚函数p-fun()

CallVirtualFun(p,1);//调用虚函数p-fun2()

system("pause");

}

现在我们拥有一个“通用”的CallVirtualFun方法。

这个通用方法和第三部分开始处的代码有何联系呢？联系很大。由于A::fun()和A::fun2()是虚函数，所以A::fun和A::fun2获得的不是函数的地址，而是一段间接获得虚函数地址的一段代码的地址，我们形象地把这段代码看作那段CallVirtualFun。编译器在编译时，会提供类似于CallVirtualFun这样的代码，当你调用虚函数时，其实就是先调用的那段类似CallVirtualFun的代码，通过这段代码，获得虚函数地址后，最后调用虚函数，这样就真正保证了多态性。同时大家都说虚函数的效率低，其原因就是，在调用虚函数之前，还调用了获得虚函数地址的代码。

最后的说明：本文的代码可以用VC6和Dev-C++4.9.8.0通过编译，且运行无问题。其他的编译器小弟不敢保证。其中，里面的类比方法只能看成模型，因为不同的编译器的低层实现是不同的。例如this指针，Dev-C++的gcc就是通过压栈，当作参数传递，而VC的编译器则通过取出地址保存在ecx中。所以这些类比方法不能当作具体实现

在C++ 中虚拟函数怎么用的，实现什么功能

虚函数的作用就是接口类能够提供协议（即这个接口的功能是什么，比如都是进行绘画，相对来说比较抽象），而各个子类可以给出具体不同的实现（比如长方形绘画时可以画出长方形，而三角形则画出来的就是三角形）。调用虚函数的客户只需要知道虚函数的提供的协议，而不需要关心这个实现这个虚函数的到底是个什么类（因为都是从一个基类继承的）。

当然你可能会想，为什么不能用非虚函数做上面的事情，我们可以实现时指定一个类型，比如有一个成员用来标识形状的类型，而在实现时用这个类型来判定如何进行绘画，简而言之就是if else或者switch语句，如同下面的代码：

class shape {

int type;

public:

void draw() {

switch (type) {

case rectangle:

draw_rectangle();

break;

case circle:

draw_circle();

break;

}

};

这个问题在于，当你有一个很多shape时，这个switch case将难以管理，因为有时候代码中有些地方就是需要根据类型来做判断，但是此时你会倾向于使用switch case来实现这些代码。久而久之，一旦加个新类型时，就会很难维护，因为要改动很多地方，就容易出错（当然如果改动地方不多，问题不会很大）。

但是如果使用虚函数实现，那么各个子类管理自己的实现，而有需要依据类型来判断的地方，可以通过虚函数来实现，因为每个类可以定制这种行为，对于draw而言，可以

class rectangle : public shape {

public:

virtual void draw() {

// draw rectangle;

}

};

class circle : public shape {

public:

virtual void draw() {

// draw circle

}

};

这样当我们需要加新shape的时候，只需要添加一个新的子类，实现draw（或者其他依赖于类型的函数时），就不用到处去修改那些swtich case语句了，也不容易出错了。

敏捷开发一书中，提到的OCP（开放封闭原则），就可以用虚函数来做到。

C++中虚函数的作用是什么？它应该怎么用呢？

C++中虚函数的作用：

1、为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。

2、在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。

为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数（方法：virtual ReturnType Function()= 0;），则编译器要求在派生类中必须予以重写以实现多态性。

同时含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就很好地解决了上述两个问题。

C++中虚函数的用法：

比如你有个游戏，游戏里有个虚基类叫「怪物」，有纯虚函数 「攻击」。然后派生出了三个子类「狼」「蜘蛛」「蟒蛇」，都实现了自己不同的「攻击」函数，比如狼是咬人，蜘蛛是吐丝，蟒蛇把你缠起来。

然后出现好多怪物的时候就可以定义一个 虚基类指针数组，把各种怪物的指针给它，然后迭代循环的时候直接 monster[i]-attack() 攻击玩家就行了，大概见下图：

扩展资料：

使用虚函数的注意事项：

一、包含虚函数的类指针列表会增大。

二、虚析构函数

析构函数的作用是在对象撤销之前做必要的“清理现场”的工作。当派生类的对象从内存中撤销的时候，会先先调用派生类的析构函数然后再调用基类的析构函数。

当我们new一个临时对象时，若基类中包含析构函数，并且定义了一个指向该基类的指针变量。

三、构造函数不能声明为虚函数

构造函数不能声明为虚函数。如果声明为虚函数，编译器会自动报出。

四、不在析构或者构造过程中调用虚函数

在析构函数或者是构造函数中，我们绝对不能调用虚函数。即使，我们在构造函数或者析构函数中调用虚函数，也不会下降至派生类中调用函数。

名称栏目：c语言虚函数的实现 c语言虚数怎么表示
当前网址：http://myzitong.com/article/dddjcdo.html