對于C++動態綁定的理解，就是編譯器用靜態分析的方法加上虛擬函數的設計實現在程序運行時動態智能執行正確虛擬函數的技術。要徹底理解動態綁定，只需要掌握兩點，一是編譯器的靜態編譯過程，二是虛擬函數的基本知識。只要有了這兩點理解，任何動態綁定的分析都是很容易的

C++實現動態綁定代碼分享

1. #include <iostream> 
2. #include<string> 
3. using namespace std; 
4. class BookItem 
5. { 
6. private: 
7. string bookName; 
8. size_t cnt; 
9. public: 
10. BookItem(const string&s,size_t c,double p): 
11. bookName(s),cnt(c),price(p) 
12. {} 
13. ~BookItem(){} 
14. protected: 
15. double price; 
16. public: 
17. double bookPrice() 
18. { 
19. return this->price; 
20. } 
21. string getBookName() 
22. { 
23. return this->bookName; 
24. } 
25. size_t getBookCount() 
26. { 
27. return this->cnt; 
28. } 
29. virtual double money() 
30. { 
31. return cnt*price; 
32. } 
33. virtual void costMoney() 
34. { 
35. cout<<money()<<endl; 
36. } 
37. }; 
38. class BookBatchItem:public BookItem 
39. { 
40. private: 
41. string bookName; 
42. size_t cnt; 
43. public: 
44. BookBatchItem(const string&s,size_t c,double p,double discountRate): 
45. BookItem(s,c,p),cnt(c),discount(discountRate) 
46. {} 
47. ~BookBatchItem(){} 
48. private: 
49. double discount; 
50. public: 
51. double money() 
52. { 
53. if(cnt>=10) 
54. return cnt*price*(1.0-discount); 
55. else 
56. return cnt*price; 
57. } 
58. void costMoney() 
59. { 
60. cout<<money()<<endl; 
61. // cout<<cnt<<endl; 
62. // cout<<price<<endl; 
63. // cout<<discount<<endl; 
64. // cout<<"..."<<endl; 
65. } 
66. }; 
67. int main() 
68. { 
69. BookItem b1("Uncle Tom's house",11,12.5); 
70. b1.costMoney(); 
71. BookBatchItem b2("Gone with wind",11,12.5,0.12); 
72. b2.costMoney(); 
73. BookItem* pb=&b1; 
74. pb->costMoney(); 
75. pb=&b2; 
76. pb->costMoney(); 
77. return 0; 
78. } 

只有采用“指針->函數()”或“引用.函數()”的方式調用C++類中的虛函數才會執行動態綁定，非虛函數并不具備動態綁定的特征，不管采用任何方式調用都不行。

下面代碼中，一個java或者C#的程序員容易犯的一個錯誤。

1. class Base 
2. { 
3. public: 
4. Base() { p = new char ; } 
5. ~Base() { delete p; } 
6. private: 
7. char * p ; 
8. }; 
9.  
10. class Derived:public Base 
11. { 
12. public: 
13. Derived() { d = new char[10] ; } 
14. ~Derived() { delete[] d; } 
15. private: 
16. char * d ; 
17. }; 
18.  
19. int main() 
20. { 
21. Base *pA = new Derived(); 
22. delete pA ; 
23.  
24. Derived *pA = new Derived(); 
25. delete pA ; 
26. } 

代碼中：

執行delete pA時，直接執行~Base析構函數，不會執行~Derived析構函數的，原因在于析構函數不是虛函數。

執行delete pB時，先執行~Derived()然后再執行~Base()。

相比之下，java和C#中，所有的函數調用都是動態綁定的。

關于C++的成員函數調用與綁定方式，可以通過下面的代碼測試：

1. class Base 
2. { 
3. public: 
4. virtual void Func() { cout<<"Base"<<endl; } 
5. }; 
6.  
7. class Derived:public Base 
8. { 
9. public: 
10. virtual void Func() { cout<<"Derived"<<endl; } 
11. }; 
12.  
13. int main() 
14. { 
15. Derived obj; 
16. Base * p1 = &obj; 
17. Base & p2 = obj; 
18. Base obj2 ; 
19.  
20. obj.Func() ; //靜態綁定，Derived的func 
21. p1->Func(); //動態綁定，Derived的func 
22. (*p1).Func(); //動態綁定，Derived的func 
23. p2.Func(); //動態綁定，Derived的func 
24. obj2.Func(); //靜態綁定，Base的func 
25.  
26. return 0 ; 
27. } 

可以看出“對象名.函數()”屬于靜態綁定，當然，使用指針轉換為對象的方式應該屬于指針調用那一類了，至于“類名::函數()”毫無疑問屬于靜態綁定。