虚函数的实际存在意义是什么?

weixianlang

本来还以为是基类的函数为一个普遍属性,但是某些子类有特殊的功能,所以就有了虚函数,可是做了个实验,有与没有都一样:
望高手指教!
如:

1. 
   
2. animal.h
   
3. 
   
4. #ifndef A_h
   
5. #define A_h
   
6. class A
   
7. {
   
8. public:
   
9. void eat();
   
10. void sleep();
    
11. virtual void breathe();           不管这里是否加上virtual,输出的结果都是子类的函数的行为;我是不是理解错了,
    
12. };                                           该怎么理解望指教!!!!
    
13. 
    
14. #endif
    
15. 
    
16. 
    
17. 
    
18. 
    
19. 
    
20. 
    
21. 
    
22. fish.h
    
23. 
    
24. #include "animal.h"
    
25. 
    
26. #ifndef fish_h
    
27. #define fish_h
    
28. class F:public A
    
29. {
    
30. public:
    
31. F(){};
    
32. void breathe();
    
33. };
    
34. #endif
    
35. 
    
36. 
    
37. 
    
38. 
    
39. 
    
40. 
    
41. 
    
42. 
    
43. animal.cpp
    
44. 
    
45. #include "animal.h"
    
46. #include <IOSTREAM>
    
47. using namespace std;
    
48. 
    
49. void A::eat()
    
50. {
    
51. cout<<"animal eat\n";
    
52. }
    
53. 
    
54. void A::sleep()
    
55. {
    
56. cout<<"animal sleep\n";
    
57. }
    
58. 
    
59. void A::breathe()
    
60. {
    
61. cout<<"animal breathe\n";
    
62. 
    
63. 
    
64. 
    
65. 
    
66. 
    
67. 
    
68. 
    
69. 
    
70. 
    
71. fish.cpp
    
72. 
    
73. #include "fish.h"
    
74. #include <IOSTREAM.h>
    
75. 
    
76. 
    
77. void F::breathe()
    
78. {
    
79. cout<<"fish bubble\n";
    
80. }
    
81. 
    
82. 
    
83. 
    
84. 
    
85. 
    
86. 
    
87. main.cpp
    
88. 
    
89. #include <IOSTREAM.H>
    
90. 
    
91. #include "animal.h"
    
92. 
    
93. #include "fish.h"
    
94. 
    
95. 
    
96. int main()
    
97. {
    
98. A an1;
    
99. F fs1;
    
100. fs1.breathe();
     
101. return 0;
     
102. 
     
103. };
     

复制代码

仰望天上的光

主函数改为这个就看出作用了。

1. int main(){
   
2.   A an1;
   
3.   F fs1;
   
4.   A* p = &an1;
   
5.   p->breathe();
   
6.   p = &fs1;
   
7.   p->breathe();
   
8.   return 0;
   
9. }

复制代码

weixianlang

回复 仰望天上的光 的帖子

1. int main()
   
2. {
   
3.     A an1;
   
4.         F fs1;
   
5.         A* P=&an1;
   
6.         F* p1=&fs1;
   
7.         P->breathe();
   
8.         p1->breathe();
   
9.         return 0;
   
10.        
    
11. };

复制代码

既然我可以这样访问子类,为何还要像你那样间接用一个指针?说下实际意义,比如哪些东西可以用到?

仰望天上的光

LZ的代码对于具体类编程，使得使用这些类的人需要了解你写的每一个类，想象一种情况，我们从class A派生出很多的类，如class Fish, class cat, class dog每个类都实现了自己不同的虚函数breathe();
那么我们在main函数中可以作如下使用：
A* p = GetAnAnimal();
p->breathe();
其中GetAnAnimal();函数原型是：
A* GetAnAnimal();将随机生成某种动物的对象并返回指向它的指针。
使用该函数的人不需要知道GetAnAnimal();具体返回什么类(其实也不可能知道)，只要知道返回的是个指向A类型的指针，又类型A具有函数breathe();可以调用，那么通过返回的指针调用breathe();函数，将会调用到具体类型的breathe();动作

以后假如又增加了新的动物，那么只要修改函数GetAnAnimal();而使用该函数的代码不需要作任何的修改。这个才是虚函数(面向对象)的威力-- 在实现大规模程序的时候，增加功能(增加其它动物的类)不需要修改原来的代码，只要增加代码就可以了

weixianlang

回复 仰望天上的光 的帖子

大致上理解了,感谢!