顯式重載虛函數(C++11特性)

GCC4.7.0已經支持C++11標准的大部分功能了，今天嘗試了下C++11的顯式重載虛函數機制，感覺還是非常靈活的，語法結構如下：

1. #include <iostream>   
2.   
3.   
4. class A  
5. {  
6.     public:  
7.         virtual void fun1()  
8.         {  
9.             std::cout << "A:1" << std::endl;  
10.         };  
11.         virtual void fun2()final  
12.         {  
13.             std::cout << "A:2" << std::endl;  
14.         }  
15.         virtual void fun3()  
16.         {  
17.             std::cout << "A:3" << std::endl;  
18.         }  
19.         void fun4()  
20.         {  
21.             std::cout << "A:4" << std::endl;  
22.         }  
23.         virtual void fun5()  
24.         {  
25.             std::cout << "A:5" << std::endl;  
26.         }  
27. };  
28.   
29.   
30. class B final: public A  
31. {  
32.     public:  
33.         virtual void fun1()override//(1)   
34.         {  
35.             std::cout << "B:1" << std::endl;  
36.         }  
37.         /*virtual void fun2()override//(2) 
38.         { 
39.             std::cout << "B:2" << std::endl; 
40.         }*/  
41.         /*virtual void fun2()(3) 
42.         { 
43.             std::cout << "B:2" << std::endl; 
44.         }*/  
45.         /*void fun2()(4) 
46.         { 
47.             std::cout << "B:2" << std::endl; 
48.         }*/  
49.         virtual void fun3()//(5)   
50.         {  
51.             std::cout << "B:3" << std::endl;  
52.         }  
53.         /*virtual void fun4()override//(6) 
54.         { 
55.             std::cout << "B:4" << std::endl; 
56.         }*/  
57.         virtual void fun4()//(7)   
58.         {  
59.             std::cout << "B:4" << std::endl;  
60.         }  
61.         void fun5()override//(8)   
62.         {  
63.             std::cout << "B:5" << std::endl;  
64.         }  
65. };  
66.   
67.   
68. int main()  
69. {  
70.     std::cout << "A" << std::endl;  
71.     A a;  
72.     a.fun1();  
73.     a.fun2();  
74.     a.fun3();  
75.     a.fun4();  
76.     a.fun5();  
77.   
78.   
79.     std::cout << "B" << std::endl;  
80.     B b;  
81.     b.fun1();  
82.     b.fun2();  
83.     b.fun3();  
84.     b.fun4();  
85.     b.fun5();  
86.   
87.   
88.     std::cout << "A*" << std::endl;  
89.     A* p = new B();  
90.     p->fun1();  
91.     p->fun2();  
92.     p->fun3();  
93.     p->fun4();  
94.     p->fun5();  
95. }  

(1)顯式重載基類虛函數fun1

(2)顯式重載final的基類虛函數，編譯錯誤。final語法禁止派生類重載該虛函數。

(3)隱式重載基類final虛函數，編譯錯誤。

(4)不聲明virtual並隱式重載基類final虛函數，編譯錯誤。

(5)隱式重載基類虛函數，跟(1)比較有個缺陷：如果基類中不存在這個虛函數在編譯期無法檢測到錯誤

(6)顯式重載基類的普通成員函數，override只能重載虛函數，故編譯錯誤。

(7)重新聲明fun4函數為虛函數，覆蓋基類的fun4而不是重載。

(8)顯式重載基類虛函數fun5而不許要明確聲明virtual。

綜上所述：

（1）在派生類中重載基類虛函數應該顯式使用override，避免重載基類中不存在的虛函數，會在編譯期檢查到錯誤。

（2）如果想終止基類中的虛函數方法，而在B的類中不被重載需要明確的添加final修飾。

（3）一旦一個的類的成員函數被聲明為虛函數，那麼就要麼被重載要麼被禁止重載，永遠無法覆蓋。