c++ 多態

    多態是c++中很重要的一環。多態可以分為以下幾個層面來剖析：

    1.對象的類型

    2.多態

    3.虛表

    先說第一點對象的類型，這個非常簡單。比如說、

int a;

    那么我就定義了一個int類型的變量a。再來看下面的代碼

class Base
{

};

class Derive:public Base
{

};

    這里我寫了一個Base類和一個Derive類，并且Derive類是派生于Base類

Base b;
Derive d;

Base* pb=&b;
pb=&d;

    上面的代碼實例化了一個Base類類型的對象b，Derive類類型的對象d，Base*類型的指針pb。

pb的靜態類型就是Base*類型，我們也可以讓pb指向d，Derive*就是pb的動態類型。

    下面來說說第二點，多態。

int Add(int left,int right)
{
    return left+right;
}

double Add(double left,double right)
{
    return left+right;
}

    上面這兩個函數構成了函數的重載，傳進去int類型的參數就調用上面的，double類型的參數就調用下面的。這也是一種多態，稱為靜態的多態。還有一種泛型編程也是靜態的多態。靜態多態就是在編譯器編譯期間完成的，編譯器根據函數的實參的類型（可能進行隱式的類型轉換），可推斷出到底要調用哪個函數，如果有對應的函數就調用該函數，否則就會出現編譯錯誤。

    那么動態多態（也叫動態綁定）就是指在程序執行期間判斷所引用對象的實際類型，根據其實際類型調用相應的方法。

    使用virtual關鍵字來修飾函數，指明該函數為虛函數，派生類需要重新實現，編譯器將實現動態綁定。

    所謂虛函數就是指在類中被聲明為virtual的成員，基類希望這種成員在派生類中重定義。除了構造函數外，任意非static成員都可以為虛成員。保留字 virtual 只在類內部的成員函數聲明中出現，不能用在類定義體外部出現在函數定義上。

    看一段代碼：

class Base
{
public:
    virtual void FunTest()
    {
        cout<<"Base::FunTest()"<<endl;
    }
};

class Derive :public Base
{
public:
    void FunTest()
    {
        cout<<"Derive::FunTest()"<<endl;
    }
};

int main()
{
    Derive d;
    d.FunTest();
    
    Base b;
    b.FunTest();
    
    Base *pb=&b;
    pb->FunTest();
    pb=&d;
    pb->FunTest();
    
    return 0;
}

    在這一段代碼里面，我定義了兩個類一個是Base，另一個是他的派生類Derive。Base類里面有一個虛函數FunTest（），Derive類里面也有一個FunTest（）。并且在主函數里面實例化了兩個類的對象，并且調用了FunTest函數，下面也定義了Base*類型的指針，先指向b，然后調用了FunTest函數，之后指向d，然后調用FunTest函數。這段代碼運行結果會是什么樣呢？

    正如我們所看到的調用派生類里面的函數他有他就調用他自己的，他沒有再去基類里面找。 

    那么動態綁定實現的條件是什么呢？第一，必須要是虛函數。第二，要通過基類類型的引用或者指針調用。

class CBase
{
public:
	virtual void FunTest1(int _iTest)
	{
		cout << "CBase::FunTest1()" << endl;
	}
	void FunTest2(int _iTest)
	{
		cout << "CBase::FunTest2()" << endl;
	}
	virtual void FunTest3(int _iTest1)
	{
		cout << "CBase::FunTest3()" << endl;
	}
	virtual void FunTest4(int _iTest)
	{
		cout << "CBase::FunTest4()" << endl;
	}

};


class CDerive:public CBase
{
public:
	virtual void FunTest1(int _iTest)
	{
		cout << "CDerive::FunTest1()" << endl;
	}
	virtual void FunTest2(int _iTest)
	{
		cout << "CDerive::FunTest2()" << endl;
	}
	void FunTest3(int _iTest1)
	{
		cout << "CDerive::FunTest3()" << endl;
	}
	virtual void FunTest4(int _iTest1,int _iTest2)
	{
		cout << "CDerive::FunTest4()" << endl;
	}
};

int main()
{
	CBase* pBase = new CDerive;
	pBase->FunTest1(0);
	pBase->FunTest2(0);
	pBase->FunTest3(0);
	pBase->FunTest4(0);
	return 0;
}

    上面是一個例子，CBase類是CDerive類的基類。之后FunTest1()是一個虛函數，FunTest2（）不是一個虛函數，FunTest3（）也是虛函數，FunTest4()雖然是虛函數但是在子類里面重新實現給了兩個參數。所以運行結果是這樣的：

    假如我們想調用CDerive里面的FunTest4(),我們就要用CDerive類的對象了。就像下面這樣：

        CDerive d;
	d.FunTest4(0, 0);

    我們這里有一個圖片，能看明白繼承體系中同名成員函數的關系：

    這里還需要注意：構造函數是不可以定義為虛函數的，因為構造函數是用來構建我們的對象 的，構造函數沒有執行完我們的對象就是不完整的。假如我們要調用構造函數，是需要通過我們的基類對象來調用的，但是我們的對象都沒有構造完，所以是不能這樣的。

    靜態函數和友元函數也同樣不可以用virtual來修飾。因為這兩種函數都沒有this指針。

    這里還有一個東西：

class test
{
	virtual void Test() = 0;
};

    這段代碼定義的類叫抽象類。它不能夠實例化產生對象，它只是提供一些接口。它里面的那個函數后面跟了一個=0，表示它是純虛函數，它表示它的派生類要對它這個函數進行重寫。

    最后來說虛表和虛指針。

    當我們求sizeof（test）時，我們得出的結果是4。為什么呢？對類求大小的時候不應該是它的成員的大小嗎？這里就是有一個虛指針。那這個虛指針指向那里呢？是指向的虛表。虛表里面存的就是虛函數的地址。

    舉一個例子：

class test
{
public:
	virtual void FunTest1()
	{}
	virtual void FunTest2()
	{}
	virtual void FunTest3()
	{}
	virtual void FunTest4()
	{}
};

    這個類里面只有四個虛函數，那么sizeof(test)等于多少呢？

    再來看看t中到底有什么：

    所以當我們要調用虛函數的時候，編譯器是先找到我們的虛表地址，之后找到對應的虛函數。