C++中的虚函数（一）

虽然很难找到一本不讨论多态性的C++书籍或杂志，但是，大多数这类讨论使多态性和C++虚函数的使用看起来很难。我打算在这篇文章中通过从几个方面和结合一些例子使读者理解在C++中的虚函数实现技术。说明一点，写这篇文章只是想和大家交流学习经验因为本人学识浅薄，难免有一些错误和不足，希望大家批评和指正，在此深表感谢！

一、 基本概念

首先，C++通过虚函数实现多态."无论发送消息的对象属于什么类，它们均发送具有同一形式的消息，对消息的处理方式可能随接手消息的对象而变"的处理方式被称为多态性。"在某个基类上建立起来的类的层次构造中，可以对任何一个派生类的对象中的同名过程进行调用，而被调用的过程提供的处理可以随其所属的类而变。"虚函数首先是一种成员函数，它可以在该类的派生类中被重新定义并被赋予另外一种处理功能。

二、 虚函数的定义与派生类中的重定义

01. class 类名{

02. public:

03. virtual 成员函数说明；

04. }

05.  

06. class 类名：基类名{

07. public:

08. virtual 成员函数说明；

09. }

三、 虚函数在内存中的结构

1．我们先看一个例子：

01. #include "iostream.h"

02. #include "string.h"

03.  

04. class A {

05. public:

06. virtual void fun0() { cout << "A::fun0" << endl; }

07. };

08.  

09.  

10. int main(int argc, char* argv[])

11. {

12. A  a;

13. cout << "Size of A = " << sizeof(a) << endl;

14. return 0;

15. }

结果如下：Size of A = 4

2．如果再添加一个虚函数：virtual void fun1() { cout << "A::fun" << endl;}

得到相同的结果。如果去掉函数前面的virtual修饰符

01. class A {

02. public:

03. void fun0() { cout << "A::fun0" << endl; }

04. };

05.  

06.  

07. int main(int argc, char* argv[])

08. {

09. A  a;

10. cout << "Size of A = " << sizeof(a) << endl;

11. return 0;

12. }

结果如下：Size of A = 1

3．在看下面的结果：

01. class A {

02. public:

03. virtual void fun0() { cout << "A::fun0" << endl; }

04. int a;

05. int b;

06. };

07. int main(int argc, char* argv[])

08. {

09. A  a;

10. cout << "Size of A = " << sizeof(a) << endl;

11. return 0;

12. }

结果如下：Size of A = 12

其实虚函数在内存中结构是这样的:

图一

在window2000下指针在内存中占4个字节，虚函数在一个虚函数表(VTABLE)中保存函数地址。在看下面例子。

01. class A {

02. public:

03. virtual void fun0() { cout << "A::fun0" << endl; }

04. virtual void fun1() { cout << "A::fun1" << endl; }

05. int a;

06. int b;

07. };

08. int main(int argc, char* argv[])

09. {

10. A  a;

11. cout << "Size of A = " << sizeof(a) << endl;

12. return 0;

13. }

结果如下：结果如下：

Size of A = 4

虚函数的内存结构如下，你也可以通过函数指针，先找到虚函数表(VTABLE),然后访问每个函数地址来验证这种结构，在国外网站作者是：Zeeshan Amjad写的"ATL on the Hood中有详细介绍"

图二

4．我们再来看看继承中虚函数的内存结构，先看下面的例子

01. class A {

02. public:

03. virtual void f() { }

04. };

05. class B {

06. public:

07. virtual void f() { }

08. };

09. class C {

10. public:

11. virtual void f() { }

12. };

13. class Drive : public A, public B, public C {

14. };

15. int main() {

16. Drive d;

17. cout << "Size is = " << sizeof(d) << endl;

18. return 0;

19. }

结果如下：Size is = 12 ，相信大家一看下面的结构图就会很清楚，

图三

5.我们再来看看用虚函数实现多态性，先看个例子：

01. class A {

02. public:

03. virtual void f() { cout << "A::f" << endl; }

04. };

05. class B :public A{

06. public:

07. virtual void f() { cout << "B::f" << endl;}

08. };

09. class C :public A {

10. public:

11. virtual void f() { cout << "C::f" << endl;}

12. };

13. class Drive : public C {

14. public:

15. virtual void f() { cout << "D::f" << endl;}

16. };

17.  

18. int main(int argc, char* argv[])

19. {

20. A a;

21. B b;

22. C c;

23. Drive d;

24. a.f();

25. b.f();

26. c.f();

27. d.f();

28. return 0;

29. }

30. 结果：A::f

31. B::f

32. C::f

33. D::f

不用解释，相信大家一看就明白什么道理！注意：多态不是函数重载

6．用虚函数实现动态连接在编译期间，C++编译器根据程序传递给函数的参数或者函数返回类型来决定程序使用那个函数，然后编译器用正确的的函数替换每次启动。这种基于编译器的替换被称为静态连接，他们在程序运行之前执行。另一方面，当程序执行多态性时，替换是在程序执行期进行的，这种运行期间替换被称为动态连接。如下例子：

01. class A{

02. public:

03. virtual void f(){cout < <  "A::f" < <  endl;};

04. };

05.  

06. class B:public A{

07. public:

08. virtual void f(){cout < <  "B::f" < <  endl;};

09. };

10. class C:public A{

11. public:

12. virtual void f(){cout < <  "C::f" < <  endl;};

13. };

14. void test(A *a){

15. a->f();

16. };

17. int main(int argc, char* argv[])

18. {    

19. B *b=new B;

20. C *c=new C;

21. char choice;

22. do{

23. cout< < "type  B for class B,C for class C:"< < endl;

24. cin>>choice;

25. if(choice==''b'')

26. test(b);

27. else if(choice==''c'')

28. test(c);

29. }while(1);

30. cout< < endl< < endl;

31. return 0;

32. }

在上面的例子中，如果把类A,B,C中的virtual修饰符去掉，看看打印的结果，然后再看下面一个例子想想两者的联系。如果把B和C中的virtual修饰符去掉，又会怎样，结果和没有去掉一样。 

7．在基类中调用继承类的函数（如果此函数是虚函数才能如此）

还是先看例子：

01. class A {

02. public:

03. virtual void fun() {

04. cout << "A::fun" << endl;

05. }

06. void show() {

07. fun();

08. }

09. };

10.  

11. class B : public A {

12. public:

13. virtual void fun() {

14. cout << "B::fun" << endl;

15. }

16. };

17.  

18. int main() {

19. A a;

20. a.show();

21.  

22. return 0;

23. }

打印结果：A::fun 

在6中的例子中，test(A *a)其实有一个继承类指针向基类指针隐式转化的过程。可以看出利用虚函数我们可以在基类调用继承类函数。但如果不是虚函数，继承类指针转化为基类指针后只可以调用基类函数。反之，如果基类指针向继承类指针转化的情况怎样，这只能进行显示转化，转化后的继承类指针可以调用基类和继承类指针。如下例子：

01. class A {

02. public:

03. void fun() {

04. cout << "A::fun" << endl;

05. }

06.  

07. };

08. class B : public A {

09. public:

10. void fun() {

11. cout << "B::fun" << endl;

12. }

13. void fun0() {

14. cout << "B::fun0" << endl;

15. }

16. };

17. int main() {

18. A *a=new A;

19. B *b=new B;

20. A *pa;

21. B *pb;

22. pb=static_cast(a); //基类指针向继承类指针进行显示转化

23. pb->fun0();

24. pb->fun();

25. return 0;

26. }

 参考资料：

1.科学出版社 《C++程序设计》

2．Zeeshan Amjad 《ATL on the Hood》

FROM: http://www.vckbase.com/index.php/wv/703