• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>

    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>

            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>
            

    
            

            




            







												


        


            
山寨：不是最好的，是最適合我們的！歡迎體驗山寨 中文版MSDN


            




            
	

            Blog @ Blog
            

              當華美的葉片落盡，生命的脈絡才歷歷可見。 －－ 聶魯達    

            

            


            
	
		

            常用鏈接
            

		

            統計
            
	
		

            積分與排名
            


		
		
            BBS
            
		
				
			
	
		
            Blog
            
		
				
			
	
		
            Web
            
		
				
			
	

		

            最新評論
	
            

            
	
			
		

            
		
	

            

            
	
					
	
            
		
            
			C++中的虛函數(virtual function)
		
            
		1.簡介 
                虛函數是C++中用于實現多態(polymorphism)的機制。核心理念就是通過基類訪問派生類定義的函數。假設我們有下面的類層次：

            

            class A
            {
            public:
                            virtual void foo() { cout << "A::foo() is called" << endl;}
            }            ;

            class B: public A
            {
            public:
                            virtual void foo() { cout << "B::foo() is called" << endl;}
            }            ;
            


            那么，在使用的時候，我們可以：

            A * a = new B();
            a->foo();       // 在這里，a雖然是指向A的指針，但是被調用的函數(foo)卻是B的!

                這個例子是虛函數的一個典型應用，通過這個例子，也許你就對虛函數有了一些概念。它虛就虛在所謂“推遲聯編”或者“動態聯編”上，一個類函數的調用并不是在編譯時刻被確定的，而是在運行時刻被確定的。由于編寫            代碼的時候并不能確定被調用的是基類的函數還是哪個派生類的函數，所以被成為“虛”函數。

                虛函數只能借助于指針或者引用來達到多態的效果，如果是下面這樣的代碼，則雖然是虛函數，但它不是多態的：

            

            class A
            {
            public:
                            virtual void foo();
            }            ;

            class B: public A
            {
                            virtual void foo();
            }            ;

            void bar()
            {
                A a;
                a.foo();               // A::foo()被調用
            }
            

            1.1 多態 
                在            了解了虛函數的意思之后，再考慮什么是多態就很容易了。仍然針對上面的類層次，但是使用的方法變的復雜了一些：

            void bar(A * a)
            {
                a->foo();  // 被調用的是A::foo() 還是B::foo()？
            }

            因為foo()是個虛函數，所以在bar這個函數中，只根據這段代碼，無從確定這里被調用的是A::foo()還是B::foo()，但是可以肯定的說：如果a指向的是A類的實例，則A::foo()被調用，如果a指向的是B類的實例，則B::foo()被調用。

            這種同一代碼可以產生不同效果的特點，被稱為“多態”。

            1.2 多態有什么用？ 
                多態這么            神奇，但是能用來做什么呢？這個命題我難以用一兩句話概括，一般的C++教程（或者其它面向對象語言的教程）都用一個畫圖的例子來展示多態的用途，我就不再重復這個例子了，如果你不知道這個例子，隨便找本書應該都有介紹。我試圖從一個抽象的角度描述一下，回頭再結合那個畫圖的例子，也許你就更容易理解。

                在面向對象的編程中，首先會針對數據進行抽象（確定基類）和繼承（確定派生類），構成類層次。這個類層次的使用者在使用它們的時候，如果仍然在需要基類的時候寫針對基類的代碼，在需要派生類的時候寫針對派生類的代碼，就等于類層次完全暴露在使用者面前。如果這個類層次有任何的改變（增加了新類），都需要使用者“知道”（針對新類寫代碼）。這樣就增加了類層次與其使用者之間的耦合，有人把這種情況列為程序中的“bad smell”之一。

                多態可以使程序員脫離這種窘境。再回頭看看1.1中的例子，bar()作為A-B這個類層次的使用者，它并不知道這個類層次中有多少個類，每個類都叫什么，但是一樣可以很好的工作，當有一個C類從A類派生出來后，bar()也不需要“知道”（修改）。這完全歸功于多態--編譯器針對虛函數產生了可以在運行時刻確定被調用函數的代碼。

            1.3 如何“動態聯編” 
                編譯器是如何針對虛函數產生可以再運行時刻確定被調用函數的代碼呢？也就是說，虛函數實際上是如何被編譯器處理的呢？Lippman在深度探索C++對象模型[1]中的不同章節講到了幾種方式，這里把“標準的”方式簡單介紹一下。

                我所說的“標準”方式，也就是所謂的“VTABLE”機制。編譯器發現一個類中有被聲明為virtual的函數，就會為其搞一個虛函數表，也就是VTABLE。VTABLE實際上是一個函數指針的數組，每個虛函數占用這個數組的一個slot。一個類只有一個VTABLE，不管它有多少個實例。派生類有自己的VTABLE，但是派生類的VTABLE與基類的VTABLE有相同的函數排列順序，同名的虛函數被放在兩個數組的相同位置上。在創建類實例的時候，編譯器還會在每個實例的內存布局中增加一個vptr字段，該字段指向本類的VTABLE。通過這些手段，編譯器在看到一個虛函數調用的時候，就會將這個調用改寫，針對1.1中的例子：

            

            class A
            {
            public:
                            virtual void foo();
            }            ;

            class B: public A
            {
                            virtual void foo();
            }            ;

            void bar()
            {
                A a;
                a.foo();               // A::foo()被調用
            }
            


                因為派生類和基類的foo()函數具有相同的VTABLE索引，而他們的vptr又指向不同的VTABLE，因此通過這樣的方法可以在運行時刻決定調用哪個foo()函數。

                雖然實際情況遠非這么簡單，但是基本原理大致如此。

            1.4 overload和override 
                虛函數總是在派生類中被改寫，這種改寫被稱為“override”。我經?；煜?#8220;overload”和“override”這兩個單詞。但是隨著各類C++的書越來越多，后來的程序員也許不會再犯我犯過的錯誤了。但是我打算澄清一下：

            override是指派生類重寫基類的虛函數，就象我們前面B類中重寫了A類中的foo()函數。重寫的函數必須有一致的參數表和返回值（C++標準允許返回值不同的情況，這個我會在“語法”部分簡單介紹，但是很少編譯器支持這個feature）。這個單詞好象一直沒有什么合適的中文詞匯來對應，有人譯為“覆蓋”，還貼切一些。 
            overload約定成俗的被翻譯為“重載”。是指編寫一個與已有函數同名但是參數表不同的函數。例如一個函數即可以接受整型數作為參數，也可以接受浮點數作為參數。 
            2. 虛函數的語法 
                虛函數的標志是“virtual”關鍵字。

            2.1 使用virtual關鍵字 
                考慮下面的類層次：

            

            class A
            {
            public:
                            virtual void foo();
            }            ;

            class B: public A
            {
            public:
                            void foo();    // 沒有virtual關鍵字!
            }            ;

            class C: public B  // 從B繼承，不是從A繼承！
            {
            public:
                            void foo();    // 也沒有virtual關鍵字！
            }            ;
            


                這種情況下，B::foo()是虛函數，C::foo()也同樣是虛函數。因此，可以說，基類聲明的虛函數，在派生類中也是虛函數，即使不再使用virtual關鍵字。

            2.2 純虛函數 
                如下聲明表示一個函數為純虛函數：

            

            class A
            {
            public:
                            virtual void foo()=0;   // =0標志一個虛函數為純虛函數
            }            ;
            


                一個函數聲明為純虛后，純虛函數的意思是：我是一個抽象類！不要把我實例化！純虛函數用來規范派生類的行為，實際上就是所謂的“接口”。它告訴使用者，我的派生類都會有這個函數。

            2.3 虛析構函數 
                析構函數也可以是虛的，甚至是純虛的。例如：

            

            class A
            {
            public:
                            virtual ~A()=0;   // 純虛析構函數
            }            ;
            


                當一個類打算被用作其它類的基類時，它的析構函數必須是虛的?？紤]下面的例子：

            

            class A
            {
            public:
                A()             { ptra_ = new char[10];}
                            ~A() { delete[] ptra_;}        // 非虛析構函數
            private:
                            char * ptra_;
            }            ;

            class B: public A
            {
            public:
                B()             { ptrb_ = new char[20];}
                            ~B() { delete[] ptrb_;}
            private:
                            char * ptrb_;
            }            ;

            void foo()
            {
                A             * a = new B;
                delete a;
            }
            


                在這個例子中，程序也許不會象你想象的那樣運行，在執行delete a的時候，實際上只有A::~A()被調用了，而B類的析構函數并沒有被調用！這是否有點兒可怕？

                如果將上面A::~A()改為virtual，就可以保證B::~B()也在delete a的時候被調用了。因此基類的析構函數都必須是virtual的。

                純虛的析構函數并沒有什么作用，是虛的就夠了。通常只有在希望將一個類變成抽象類（不能實例化的類），而這個類又沒有合適的函數可以被純虛化的時候，可以使用純虛的析構函數來達到目的。

            2.4 虛構造函數？ 
                構造函數不能是虛的。

            3. 虛函數使用技巧 3.1 private的虛函數 
                考慮下面的例子：

            

            class A
            {
            public:
                            void foo() { bar();}
            private:
                            virtual void bar() { }
            }            ;

            class B: public A
            {
            private:
                            virtual void bar() { }
            }            ;
            


                在這個例子中，雖然bar()在A類中是private的，但是仍然可以出現在派生類中，并仍然可以與public或者protected的虛函數一樣產生多態的效果。并不會因為它是private的，就發生A::foo()不能訪問B::bar()的情況，也不會發生B::bar()對A::bar()的override不起作用的情況。

                這種寫法的語意是：A告訴B，你最好override我的bar()函數，但是你不要管它如何使用，也不要自己調用這個函數。

            3.2 構造函數和析構函數中的虛函數調用 
                一個類的虛函數在它自己的構造函數和析構函數中被調用的時候，它們就變成普通函數了，不“虛”了。也就是說不能在構造函數和析構函數中讓自己“多態”。例如：
            


            class A
            {
            public:
                A()             { foo();}        // 在這里，無論如何都是A::foo()被調用！
                ~A() { foo();}       // 同上
                virtual void foo();
            }            ;

            class B: public A
            {
            public:
                            virtual void foo();
            }            ;

            void bar()
            {
                A             * a = new B;
                delete a;
            }
            


                如果你希望delete a的時候，會導致B::foo()被調用，那么你就錯了。同樣，在new B的時候，A的構造函數被調用，但是在A的構造函數中，被調用的是A::foo()而不是B::foo()。

            3.3 多繼承中的虛函數 3.4 什么時候使用虛函數 
                在你設計一個基類的時候，如果發現一個函數需要在派生類里有不同的表現，那么它就應該是虛的。從設計的角度講，出現在基類中的虛函數是接口，出現在派生類中的虛函數是接口的具體實現。通過這樣的方法，就可以將對象的行為抽象化。

                以設計模式[2]中Factory Method模式為例，Creator的factoryMethod()就是虛函數，派生類override這個函數后，產生不同的Product類，被產生的Product類被基類的AnOperation()函數使用?；惖腁nOperation()函數針對Product類進行操作，當然Product類一定也有多態（虛函數）。

                另外一個例子就是集合操作，假設你有一個以A類為基類的類層次，又用了一個std::vector<A *>來保存這個類層次中不同類的實例指針，那么你一定希望在對這個集合中的類進行操作的時候，不要把每個指針再cast回到它原來的類型（派生類），而是希望對他們進行同樣的操作。那么就應該將這個“一樣的操作”聲明為virtual。

                現實中，遠不只我舉的這兩個例子，但是大的原則都是我前面說到的“如果發現一個函數需要在派生類里有不同的表現，那么它就應該是虛的”。這句話也可以反過來說：“如果你發現基類提供了虛函數，那么你最好override它”。

            4.參考資料 
            [1] 深度探索C++對象模型，Stanley B.Lippman，侯捷譯

            [2] Design Patterns, Elements of Reusable Object-Oriented Software, GOF 

		
            
			posted on 2008-04-27 01:15 isabc 閱讀(465) 評論(0)  編輯 收藏 引用  所屬分類: C++基礎 
		
            
	
            
	
	


	


            
	    
    




            






            

				

            








            
廣告信息(免費廣告聯系)


            


            
中文版MSDN：
             歡迎體驗


            


    
    







            
	   
	



亚洲综合久久久|
大蕉久久伊人中文字幕|
精品久久久中文字幕人妻|
国产色综合久久无码有码|
久久99精品综合国产首页|
麻豆久久|
国内精品久久久久久久97牛牛|
免费精品国产日韩热久久|
精品多毛少妇人妻AV免费久久
|
99久久精品费精品国产一区二区
|
国产成人精品久久一区二区三区av|
久久成人国产精品二三区|
亚洲国产天堂久久综合|
2021久久精品国产99国产精品|
午夜精品久久影院蜜桃|
久久精品一区二区|
青草国产精品久久久久久|
四虎亚洲国产成人久久精品|
国产V亚洲V天堂无码久久久|
亚洲国产成人久久精品99
|
久久精品成人免费国产片小草|
中文字幕久久久久人妻|
日韩久久无码免费毛片软件|
伊人丁香狠狠色综合久久|
亚洲国产欧美国产综合久久|
久久久久国产视频电影|
狠狠色综合久久久久尤物|
99久久中文字幕|
91久久精一区二区三区大全|
亚洲欧美伊人久久综合一区二区|
日本精品久久久久久久久免费|
亚洲国产精品久久久久|
人人狠狠综合久久亚洲88|
久久99精品久久久久久久久久|
精品人妻伦九区久久AAA片69|
久久无码AV中文出轨人妻|
久久天天躁狠狠躁夜夜2020|
日韩一区二区三区视频久久|
久久久久亚洲精品无码网址
|
亚洲va久久久噜噜噜久久|
伊人久久大香线蕉综合网站|