c++ 對文件操作

本文針對C++里的虛函數，虛繼承表現和原理進行一些簡單分析，有不對的地方請指出。下面都是以VC2008編譯器對這兩種機制內部實現為例。

虛函數

以下是百度百科對于虛函數的解釋：

定義：在某基類中聲明為 virtual 并在一個或多個派生類中被重新定 義的成員函數^[1]

語法：virtual 函數返回類型 函數名（參數表） { 函數體 }

用途：實現多態性，通過指向派生類的基類指針，訪問派生類中同名覆蓋成員函數

函數聲明和定義和普通的類成員函數一樣，只是在返回值之前加入了關鍵字“virtual”聲明為虛函數。而虛函數是實現多態的重要手段，意思是只有對虛函數的調用才能動態決定調用哪一個函數，這是相對于普通成員函數而言的，普通的成員函數在編譯階段就能確定調用哪一個函數。舉個栗子：

#include <stdio.h>class A {public:    void fn() { printf("fn in A\n"); }    virtual void v_fn() { printf("virtual fn in A\n"); }
};class B : public A {public:    void fn() { printf("fn in B\n"); }    virtual void v_fn() { printf("virtual fn in B\n"); }
};int main() {
    A *a = new B();
    a->fn();
    a->v_fn();    return 0;
}

基類A有兩個成員函數fn和v_fn，派生類B繼承自基類A，同樣實現了兩個函數，然后在main函數中用A的指針指向B的實例（向上轉型，也是實現多態的必要手段），然后分別調用fn和v_fn函數。結果是“fn in A”和”virtual fn in B”。這是因為fn是普通成員函數，它是通過類A的指針調用的，所以在編譯的時候就確定了調用A的fn函數。而v_fn是虛函數，編譯時不能確定，而是在運行時再通過一些機制來調用指針所指向的實例（B的實例）中的v_fn函數。假如派生類B中沒有實現（完全一樣，不是重載）v_fn這個函數，那么依然會調用基類類A中的v_fn；如果它實現了，就可以說派生類B覆蓋了基類A中的v_fn這個虛函數。這就是虛函數的表現和使用，只有通過虛函數，才能實現面向對象語言中的多態性。

以上只是虛函數的表現和用途，下面來探討它的實現機制。在此之前，先來看一個問題，還是以上的代碼，基類A的大小為多少，也就是“printf(“%d\n”, sizeof(A));”的輸出會是多少呢？A中一個成員變量都沒有，有人可能會說是0。額，0是絕對錯誤的，因為在C++中，即時是空類，它的大小也為1，這是另外的話題，不在本文討論。當然1也是不對的，實際結果是4（32位系統），4剛好是一個int，一個指針（32位）的大小，派生類B的大小同樣為4。這四個字節和實現多態，虛函數的機制有著很重要的關系。

其實用VC2008調試上面代碼的時候，就會發現指針a所指向的實力中有一個成員常量（const），它的名字叫做vftable，全稱大概叫做virtual function table（虛函數表）。它實際指向了一個數組，數組里面保存的是一系列函數指針，而上面的程序中，這個表只有一項，它就是派生類B中的v_fn函數入口地址。假如我們用一個A的指針指向一個A的實例呢？它同樣有一個vftable，而它指向的表中也只有一項，這項保存的基類的v_fn函數入口地址。這用代碼表示，就類似于下面這樣：

void* vftable_of_A[] = {
    A::v_fn,
    ...
};class A {    const void* vftable = vftable_of_A;    virtual void v_fn() {}
};void* vftable_of_B[] = {
    B::v_fn,
    ...
};class B {    const void *vftable = vftable_of_B;    vritual void v_fn() {}
};

上面vftable的類型之所以用void*表示，實際上一個類中所有虛函數的地址都被放到這個表中，不同虛函數對應的函數指針類型不盡相同，所以這個表用C++的類型不好表述，但是在機器級里都是入口地址，即一個32位的數字（32位系統），等到調用時，因為編譯器預先知道了函數的參數類型，返回值等，可以自動做好處理。

這樣我們就能更好的理解虛函數和多態了。第一個代碼中，a指針雖然是A*類型的，但是它卻調用了B中的v_fn，因為不管是A類，還是A的基類，都會有一個變量vftable，它指向的虛函數表中保存了正確的v_fn入口。所以a->v_fn()實際做的工作就是從a指向的實例中取出vftable的值，然后找到虛函數表，再從表中去的v_fn的入口，進行調用。不管a是指向A的實例，還是指向B的實例，a->fn()所做的步驟都是上面說的一樣，只是A的實例和B的實例有著不同的虛函數表，虛函數表里也保存著可能不同的虛函數入口，所以最終將進入不同的函數調用中。通過表來達到不用判斷類型，亦可實現多態的作用。還有一點指的提醒的是，因為虛函數表是一個常量表，在編譯時，編譯器會自動生成，并且不會改變，所以如果有多個B類的實例，每個實例中都會有一個vftable指針，但是它們指向的是同一個虛函數表。

上面一段中說到了，A和B的實例有著不同的虛函數表，但是虛函數表中只是可能保存著不同的v_fn，那是因為C++允許派生類不覆蓋基類中的虛函數，意思就是假如派生類B中沒有實現v_fn這個函數（不是重載），那么B的實例的虛函數表會保存著基類A中v_fn的入口地址。也就是說B類不實現v_fn函數，但是它同樣提供了這個接口，實際上是調用基類A中的v_fn。假如某個類只是一個抽象類，抽象出一些列接口，但是又不能實現這些接口，而要有派生類來實現，那么就可以把這些接口聲明為純虛函數，包含有純虛函數的類稱為抽象類。純虛函數是一類特殊的虛函數，它的聲明方式如下：

class A {public:

　　virtual 返回值 函數名（參數表）= 0；

};

在虛函數聲明方式后加一個“=0”，并且不提供實現。抽象類不允許實例化（這樣做編譯器會報錯，因為有成員函數沒有實現，編譯器不知道怎么調用）。純虛函數的實現機制和虛函數類似，只是要求派生類類必須自己實現一個（也可以不實現，但是派生類也會是個抽象類，不能實例化）。

順帶提一下，java中的每一個成員函數都可以以理解為C++中的virtual函數，不用顯式聲明都可以實現重載，多態。而java的接口類似于C++中的抽象類，需要實現里面的接口。

虛繼承

C++支持多重繼承，這和現實生活很類似，任何一個物體都不可能單一的屬于某一個類型。就像馬，第一想到的就是它派生自動物這個基類，但是它在某系地方可不可以說也派生自交通工具這一個基類呢？所以C++的多重繼承很有用，但是又引入了一個問題（專業術語叫做菱形繼承？）。動物和交通工具都是從最根本的基類——“事物”繼承而來，事物包含了兩個最基本的屬性，體積和質量。那么動物和交通工具都保存了基類成員變量——體積和質量的副本。而馬有繼承了這兩個類，那么馬就有兩份體積和質量，這是不合理的，編譯器無法確定使用哪一個，所以就會報錯。JAVA中不存在這樣的問題，因為JAVA不允許多重繼承，它只可能實現多個接口，而接口里面只包含一些函數聲明不包含成員變量，所以也不存在這樣的問題。

這個問題用具體代碼表述如下所示：

class A {public:    int a;
};class B : public A {
};class C : public A {
};class D : public B, public C {
};int main() {
    D d;
    d.a = 1;    return 0;
}

這個代碼會報錯，因為d中保存了兩份A的副本，即有兩個成員變量a，一般不會報錯，但是一旦對D中的a使用，就會報一個“對a的訪問不明確”。虛繼承就可以解決這個問題。在探討虛函數之前，先來一個sizeof的問題。

#include <stdio.h>class A {public:    int a;
};class B : virtual public A {
};int main() {    printf("%d\n", sizeof(B));    return 0;
}

B的大小是？首先回答0的是絕對錯的，理由我之前都說了。1也是錯的，不解釋。4也是錯的，如果B不是虛繼承自A的，那么4就是對的。正確答案是8，B虛繼承A了之后，比預想中的多了4個字節，這是怎么回事呢？這個通過調試是看不出來的，因為看不到類似于vftable的成員變量（實際上編譯器生成了一個類似的東西，但是調試時看不到，但是在觀察反匯編的時候，可以見到vbtable的字樣，應該是virtual base table的意思）。

虛繼承的提出就是為了解決多重繼承時，可能會保存兩份副本的問題，也就是說用了虛繼承就只保留了一份副本，但是這個副本是被多重繼承的基類所共享的，該怎么實現這個機制呢？編譯器會在派生類B的實例中保存一個A的實例，然后在B中加入一個變量，這個變量是A的實例在實際B實例中的偏移量，實際上B中并不直接保存offset的值，而是保存的一個指針，這個指針指向一個表vbtable，vbtable表中保存著所有虛繼承的基類在實例中的offset值，多個B的實例共享這個表，每個實例有個單獨的指針指向這個表，這樣就很好理解為什么多了4個字節了。用代碼表示就像下面這樣。

class A {public:
    ...
};int vbtable_of_B[] = {
　　offset(B::_a),
    ...
};class B ：virtual public A{private:    const int* vbtable = vbtable_of_B;
    A _a;
};

每一個A的虛派生類，都會有自己的vbtable表，這個派生類的所有實例共享這個表，然后每個實例各自保存了一個指向vbtable表的指針。假如還有一個類C虛繼承了A，那么編譯器就會為它自動生成一個vbtable_of_C的表，然后C的實例都會有一個指向這個vbtable表的指針。

假如有多級的虛繼承會發生什么情況，就像下面這段代碼一樣：

#include <stdio.h>class A {public:    int a;
};class B : virtual public A {public:
　　int b;
};class C : virtual public B {
};int main() {    printf("%d\n", sizeof(C));    return 0; 
}

程序運行的結果是16，按照之前的理論，大概會這么想。基類A里有1個變量，4個字節。B類虛繼承了A，所以它有一個A的副本和一個vbtable，還有自己的一個變量，那就是12字節。然后C類又虛繼承了B類，那么它有一個B的副本，一個vbtable，16字節。但實際上通過調試和反匯編發現，C中保存分別保存了A和B的副本（不包括B類的vbtable），8字節。然后有一個vbtable指針，4字節，表里面包含了A副本和B副本的偏移量。最后還有一個無用的4字節（？），一共16字節。不僅是這樣，每經過一層的虛繼承，便會多出4字節。這個多出來的四字節在反匯編中沒發現實際用途，所以這個有待探討，不管是編譯器不夠智能，還是有待其它作用，虛繼承和多重繼承都應該謹慎使用。

還是以上面的例子，假如C類是直接繼承B類，而不是使用虛繼承，那么C類的大小為12字節。它里面是直接保存了A和B的副本（不包含B的vbtable），然后還有一個自己的vbtable指針，所以一共12字節，沒有了上一段所說的最后的4個字節。

但是如果想下面一種繼承，會是什么情況？

#include <stdio.h>class A {public:    int a;
};class B : virtual public A {
};class C : virtual public A {
};class D : public B, public C{
};int main() {    printf("%d\n", sizeof(D));    return 0; 
}

D從B，C類派生出來，而B和C又同時虛繼承了A。輸出的結構是12，實際調試反匯編的時候發現，D中繼承了B和C的vbtable，這就是8字節，而同時還保存了一個A的副本，4字節，總共12字節。它和上面的多重虛繼承例子里的12字節是不一樣的。之前一個例子中只有一個vbtable，一個A的實例，末尾還有一個未知的4字節。而這個例子中是有兩個僅挨著的vbtable（都有效）和一個A的實例。