本文目录
- 虚函数多态性问题,高手请解答,急~~~~
- 虚函数有什么作用啊和多态性有什么关系
- 虚函数的作用是什么有哪些用处何处体现多态
- 一个关于C++多态性的问题
- 2. 是否使用了虚函数就能实现运行时的多态性怎样才能实现运行时的多态性
- 在c++中虚函数和多态性是什么意思
- c++高手求救 虚函数和多态性
- 为什么C++中，虚函数也能算为多态性的一种到底什么多态性的是什么
- C++疑问，实现多态性一定要用到虚函数吗
虚函数多态性问题,高手请解答,急~~~~
对虚函数来说，其实际调用的函数要根据调用者实际的类型来决定调用那一个函数。这个具体调用哪一个是在运行的时候去决定的，编程的时候不需要指明。pb-》B::fa(); 这一句里你就是要指明pb去调用B类的成员函数fa（），而pb是一个A类型的对象指针，这当然是不行的了。换句话来说：pb-》fa()，这里面调用的实际上就是B类的fa（），但是这一点系统运行的时候可以这么干，但是由你指出来让他这么干，指明要它去调用B类的fa（）还就是不允许。
虚函数有什么作用啊和多态性有什么关系
虚函数最大的好处是可以保持驱动程序的变量数据在增加派生类后可以不发生修改，已经统一程序接口，如：1.class B{public: virtual void Run()=0;};class A : public B{public: virtual void Run(){ cout《《"run A"《《endl; }};class C: public B{public: virtual void Run(){ cout《《"run B"《《endl; }};现在有一个驱动模块，如类 Drvclass Drv{public: void Execute() { b-》Run(); }private: B *b;};即使以后派生类扩展了，这个驱动程序的数据程序，已经主要函数基本不做修改，使得出错率降低。如果不用虚函数，可能的代码为：class Drv{public: void Execute() { switch(a) { case 0: a.Run(); break; case 1: c.Run(); break; //以后可能还要增加其它派生类对象 } }private: int sel A a; B b; //以后可能还要增加其它派生类对象};显然每增加一个派生类，就要对上面做多处修改！！！2. 通用接口，如：void Execute(B &b){ b.Run();}这样可以使用如：A a;Execute(a);C c;Execute(c);使得程序降低，否则需要定义给每个类为参数的函数，如：void Execute(A &a){ a.Run();}void Execute(C &c){ c.Run();}上面的两个例子可以看到虚函数的好处！！
虚函数的作用是什么有哪些用处何处体现多态
虚函数联系到多态，多态联系到继承。所以本文中都是在继承层次上做文章。没了继承，什么都没得谈。 下面是对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(){cout《《1《《endl;} virtual void fun2(){cout《《2《《endl;} }; class B:public A{ public: void fun(){cout《《3《《endl;} void fun2(){cout《《4《《endl;} }; 由于这两个类中有虚函数存在，所以编译器就会为他们两个分别插入一段你不知道的数据，并为他们分别创建一个表。那段数据叫做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指针。通过上面的分析，现在我们来实作一段代码，来描述这个带有虚函数的类的简单模型。 #include《iostream》 using namespace std; //将上面“虚函数示例代码”添加在这里 int main(){ void (*fun)(A*); A *p=new B; long lVptrAddr; memcpy(&lVptrAddr,p,4); memcpy(&fun,reinterpret_cast《long*》(lVptrAddr),4); fun(p); delete p; system("pause"); } 用VC或Dev-C++编译运行一下，看看结果是不是输出3，如果不是，那么太阳明天肯定是从西边出来。现在一步一步开始分析 void (*fun)(A*); 这段定义了一个函数指针名字叫做fun，而且有一个A*类型的参数，这个函数指针待会儿用来保存从vtbl里取出的函数地址 A* p=new B; new B是向内存(内存分5个区:全局名字空间,自由存储区,寄存器,代码空间,栈)自由存储区申请一个内存单元的地址然后隐式地保存在一个指针中.然后把这个地址附值给A类型的指针P. . long lVptrAddr; 这个long类型的变量待会儿用来保存vptr的值 memcpy(&lVptrAddr,p,4); 前面说了，他们的实例对象里只有vptr指针，所以我们就放心大胆地把p所指的4bytes内存里的东西复制到lVptrAddr中，所以复制出来的4bytes内容就是vptr的值，即vtbl的地址 现在有了vtbl的地址了，那么我们现在就取出vtbl第一个slot里的内容 memcpy(&fun,reinterpret_cast《long*》(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_cast《long*》(lVptrAddr+4),4); 为什么是加4呢？因为一个指针的长度是4bytes，所以加4。或者memcpy(&fun,reinterpret_cast《long*》(lVptrAddr)+1,4); 这更符合数组的用法，因为lVptrAddr被转成了long*型别，所以+1就是往后移sizeof(long)的长度 三， 以一段代码开始 #include《iostream》 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是真正获得了虚函数的地址吗？ 首先我们回到第二部分，通过段实作代码，得到一个“通用”的获得虚函数地址的方法 #include《iostream》 using namespace std; //将上面“虚函数示例代码2”添加在这里 void CallVirtualFun(void* pThis,int index=0){ void (*funptr)(void*); long lVptrAddr; memcpy(&lVptrAddr,pThis,4); memcpy(&funptr,reinterpret_cast《long*》(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++多态性的问题
多态性(polymorphism)是面向对象编程的基本特征之一。而在C++中，多态性通过虚函数(virtual function)来实现。我们来看一段简单的代码：#include 《iostream》using namespace std;class Base{int a;public:virtual void fun1() {cout《《"Base::fun1()"《《endl;}virtual void fun2() {cout《《"Base::fun2()"《《endl;}virtual void fun3() {cout《《"Base::fun3()"《《endl;}};class A:public Base{int a;public:void fun1() {cout《《"A::fun1()"《《endl;}void fun2() {cout《《"A::fun2()"《《endl;}};void foo (Base& obj){obj.fun1();obj.fun2();obj.fun3();}int main(){Base b;A a;foo(b);foo(a);}运行结果为：Base::fun1()Base::fun2()Base::fun3()A::fun1()A::fun2()Base::fun3()仅通过基类的接口，程序调用了正确的函数，它就好像知道我们输入的对象的类型一样！那么，编译器是如何知道正确代码的位置的呢？其实，编译器在编译时并不知道要调用的函数体的正确位置，但它插入了一段能找到正确的函数体的代码。这称之为晚捆绑(late binding)或运行时捆绑(runtime binding)技术。通过virtual关键字创建虚函数能引发晚捆绑， 编译器在幕后完成了实现晚捆绑的必要机制。它对每个包含虚函数的类创建一个表(称为VTABLE)，用于放置虚函数的地址。在每个包含虚函数的类中，编译器秘密地放置了一个称之为vpointer(缩写为VPTR) 的指针，指向这个对象的VTABLE。所以无论这个对象包含一个或是多少虚函数，编译器都只放置一个VPTR即可。VPTR由编译器在构造函数中秘密地插入的代码来完成初始化，指向相应的VTABLE，这样对象就“知道”自己是什么类型了。VPTR都在对象的相同位置，常常是对象的开头。这样，编译器可以容易地找到对象的VTABLE并获取函数体的地址。如果我们用sizeof查看前面Base类的长度，我们就会发现，它的长度不仅仅是一个int的长度，而是增加了刚好是一个void指针的长度(在我的机器里面，一个int占4个字节，一个void指针占4个字节，这样正好类Base的长度为8个字节)。每当创建一个包含虚函数的类或从包含虚函数的类派生一个类时，编译器就为这个类创建一个唯一的VTABLE。在VTABLE中，放置了这个类中或是它的基类中所有虚函数的地址，这些虚函数的顺序都是一样的，所以通过偏移量可以容易地找到所需的函数体的地址。假如在派生类中没有对在基类中的某个虚函数进行重写(overriding)，那么还使用基类的这个虚函数的地址(正如上面的程序结果所示)。至今为止，一切顺利。下面，我们的试验开始了。就目前得知的，我们可以试探着通过自己的代码来调用虚函数，也就是说我们要找寻一下编译器秘密地插入的那段能找到正确函数体的代码的足迹。如果我们有一个Base指针作为接口，它一定指向一个Base或由Base派生的对象，或者是A，或者是其它什么。这无关紧要，因为VPTR的位置都一样，一般都在对象的开头。如果是这样的话，那么包含有虚函数的对象的指针，例如Base指针，指向的位置恰恰是另一个指针——VPTR。VPTR指向的 VTABLE其实就是一个函数指针的数组，现在，VPTR正指向它的第一个元素，那是一个函数指针。如果VPTR向后偏移一个Void指针长度的话，那么它应该指向了VTABLE中的第二个函数指针了。这看来就像是一个指针连成的链，我们得从当前指针获取它指向的下一个指针，这样我们才能“顺藤摸瓜”。那么，我来介绍一个函数：void *getp (void* p){return (void*)*(unsigned long*)p;}我们不考虑它漂亮与否，我们只是试验。getp() 可以从当前指针获取它指向的下一个指针。如果我们能找到函数体的地址，用什么来存储它呢？我想应该用一个函数指针：typedef void (*fun)();它与Base中的三个虚函数相似，为了简单我们不要任何输入和返回，我们只要知道它实际上被执行了即可。然后，我们负责“摸瓜”的函数登场了：fun getfun (Base* obj, unsigned long off){void *vptr = getp(obj);unsigned char *p = (unsigned char *)vptr;p += sizeof(void*) * off;return (fun)getp(p);}第一个参数是Base指针，我们可以输入Base或是Base派生对象的指针。第二个参数是VTABLE偏移量，偏移量如果是0那么对应fun1()，如果是1对应fun2()。getfun() 返回的是fun类型函数指针，我们上面定义的那个。可以看到，函数首先就对Base指针调用了一次getp()，这样得到了vptr这个指针，然后用一个 unsigned char指针运算偏移量，得到的结果再次输入getp()，这次得到的就应该是正确的函数体的位置了。那么它到底能不能正确工作呢？我们修改main() 来测试一下：int main(){Base *p = new A;fun f = getfun(p, 0);(*f)();f = getfun(p, 1);(*f)();f = getfun(p, 2);(*f)();delete p;}激动人心的时刻到来了，让我们运行它！运行结果为：A::fun1()A::fun2()Base::fun3()至此，我们真的成功了。通过我们的方法，我们获取了对象的VPTR，在它的体外执行了它的虚函数。
2. 是否使用了虚函数就能实现运行时的多态性怎样才能实现运行时的多态性
不是使用了虚函数就能实现运行时的多态性，实现运行时多态性要满足以下4个条件：1.要有一个继承层次2.在基类要定义虚函数3.在派生类中要对基类中的虚函数进行重定义4.要通过基类指针（或基类引用）来调用虚函数
在c++中虚函数和多态性是什么意思
虚函数是在基类中定义的，目的是不确定它的派生类的具体行为。例：定义一个基类：classAnimal//动物。它的函数为breathe()//呼吸。再定义一个类classFish//鱼。它的函数也为breathe()再定义一个类classSheep//羊。它的函数也为breathe()为了简化代码，将Fish,Sheep定义成基类Animal的派生类。然而Fish与Sheep的breathe不一样，一个是在水中通过水来呼吸，一个是直接呼吸空气。所以基类不能确定该如何定义breathe，所以在基类中只定义了一个virtualbreathe,它是一个空的虚函数。具本的函数在子类中分别定义。程序一般运行时，找到类，如果它有基类，再找它的基类，最后运行的是基类中的函数，这时，它在基类中找到的是virtual标识的函数，它就会再回到子类中找同名函数。派生类也叫子类。基类也叫父类。这就是虚函数的产生，和类的多态性（breathe）的体现.这里的多态性是指类的多态性。函数的多态性是指一个函数被定义成多个不同参数的函数，它们一般被存在头文件中，当你调用这个函数，针对不同的参数，就会调用不同的同名函数。例：Rect（）//矩形。它的参数可以是两个坐标点（point，point)也可能是四个坐标(x1,y1,x2,y2)这叫函数的多态性与函数的重载。
c++高手求救 虚函数和多态性
因为你的构造函数中有B（int i）这个函数，所以当你用new B（10）的时候，就调用前面那个构造函数。而new一个对象时会返回一个这种类型的指针，即B*类型的变量。但由于B是由A继承而来，即可以用A*类型的变量来定义。总的来说，A* pa=new B(10),这句话的意思是，动态生成一个B型对象，同时以10给它初始化；new返回一个B*类型指针，给（A*）类型变量pa赋值。 比如，int *a=new int;还有就是定义对象，B b(1);这两个总明白吧，现在把两个合起来，int换成B，就变成了B* pa=new B（10）； 而B是从A继承来的，可以这样写A* pa=new B(10);//这地方不全对，但你可以先这样理解再不懂，就去看书吧，看看指针变量以及对象的定义。
为什么C++中，虚函数也能算为多态性的一种到底什么多态性的是什么
以下小程序说明了多态性
#include "stdafx.h"#include《iostream》
using namespace std;
class Base{public: virtual void vf() //只有虚函数、纯虚函数才有多态性 { cout 《《 "调用了基类函数 vf() 。" 《《 endl; }};
class A : public Base{public: void vf() { cout 《《 "调用了子类 A 函数 vf() 。" 《《 endl; }};
class B : public Base{public: void vf() { cout 《《 "调用了子类 B 函数 vf() 。" 《《 endl; }};
int _tmain(int argc, _TCHAR* argv){ Base *p, bs; A a; B b;
p = &bs; //基类指针指向基类对象 p-》vf(); //调用的是基类函数 vf()
p = static_cast《Base*》(&a);//基类指针指向类 A 对象 p-》vf();//调用的是类 A 函数 vf()
p = static_cast《Base*》(&b);//基类指针指向类 B 对象 p-》vf();//调用的是类 B 函数 vf()
//这就是多态性
system("pause"); return 0;}
运行结果：
C++疑问，实现多态性一定要用到虚函数吗
我的理解：多态性，即一个父类的引用，可以指向派生类的对象(引用的访问权限取决于引用的类型，而非对象类型)。 你这样在派生类中，写一个与父类具有相同签名的成员方法，是覆盖（有些地方说，只有虚方法才能覆盖，你可以把派生类的方法注释了，执行下，看看结果）。这个和多态性貌似没什么关系.Base *p=new Derived； p-》Fun();（此处将调用父类的Fun方法，p的访问权限为Base的权限）这才称之为多态。p是一个Base类型的引用，指向了Derived的一个实例化对象。
