2. 程式人生 > >虛擬函式,純虛擬函式的解釋和內部實現&&虛擬函式表的真實樣子

虛擬函式,純虛擬函式的解釋和內部實現&&虛擬函式表的真實樣子

阿新 • • 發佈：2019-02-05

本篇文章由zg51747708曾廣 原創，未經允許不可以轉載

注：本文章內的程式程式碼全部是在Window 7 sp1  VS2015 Update3上測試

在學習C++中我總體感覺比較難理解的概念就是虛擬函式的理解，而且比較難想到他的內部實現。於是寫下這篇部落格，來幫助大家更深入的理解虛擬函式，純虛擬函式，虛擬函式表。希望大家帶著批判來閱讀，如有錯誤請私聊我，謝謝！

一．虛擬函式與純虛擬函式定義的解釋

首先我在網上發現有些人的解釋有明顯錯誤的地方。比如說“虛擬函式是沒有定義的成員函式”。這裡要說明的是，這應該是對於純虛擬函式而言。純虛擬函式就是沒有定義的。

1.      所以虛擬函式是有定義的。

虛擬函式定義的語法如下。

virtual void fun(){}

2.      虛擬函式的產生是為了能使得父類（基類）的指標，或者引用能夠呼叫到子類（派生類）的同名函式（實現多型）。

比如下列程式(這個是用指標的例子，引用的我就寫明瞭)：

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
class Moveable {
public:
	virtual void move() {
		cout << "你有腿哦！" << endl;
	}
};
class Car : public Moveable {
public:
	void eat() {}
	void move() {
		cout << "能送四個騷貨哦！" << endl;
	}
};
class Bus : public Moveable {
public:
	void move() {
		cout << "能送一堆騷貨哦！" << endl;
	}
};

void Move(Moveable * p) {
	p->move();
}
int main() {
	Bus a;
	Car b;
	Moveable c;
	Move(&a);
	Move(&b);
	Move(&c);
	system("pause");
	return 0;
}

3.純虛擬函式才沒有定義。

純虛擬函式定義的語法如下。

virtual void fun() = 0;

虛擬函式表就是實現虛擬函式，純虛擬函式的內部方法。

---------------------------------------------------------------------------------------------------------------------------------

一．虛擬函式表的真實樣子

首先我們要知道虛擬函式表在記憶體中真正儲存的形式。可以用一下方式來測試：

#include <iostream>
#include <stdlib.h>
using namespace std;
class A {
public:
	virtual void a() {

	}
};
int main() {
	cout << sizeof(A) << endl;
	system("pause");
	return 0;
}

輸出的結果是：4

注：程式記憶體包含，程式碼段，資料段，堆段，棧段

這裡要說明的是，sizeof中並不包括成員函式所佔有的空間，因為函式存在於程式碼段，sizeof是檢測的物件佔有的記憶體空間而不包括函式。（最簡單的檢測方法是，你再在類中加一個函式，再看看sizeof返回的值，是否增加了。）

那麼問題來了，這個4個位元組是存放的什麼呢？答案就是虛擬函式表的記憶體地址。

那麼如果類中有資料成員，這個指標會在哪個位置呢？可以這樣分析，如果把這個指標放在後面。因為資料成員數量的不確定，那麼尋找這個指標將是比較費時間，而且相對而言難以實現的。而且在多重繼承或者更復雜的情況下，能夠訪問速度最大化。這樣的分析是正確的，虛擬函式表的記憶體地址就是存放在物件地址的開頭。

-------------------------------------------------------------------------------------

到這裡總結了兩點重要的，1.儲存的是虛擬函式表的記憶體地址，2.地址在物件記憶體區域的開頭。

-------------------------------------------------------------------------------------

那麼對應的虛擬函式的入口地址，在表中又是如何排列的呢？讓我們使用函式指標來測試虛擬函式在虛擬函式表中的位置吧。

1.  再沒有繼承關係時

//編譯環境Windows 7 VS2015 Update3
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
class A {
public:
	virtual void a(void) {
		cout << "A::a 函式發騷了" << endl;
	}
	virtual void b(void) {
		cout << "A::b 函式發騷了" << endl;
	}
	virtual void c(void) {
		cout << "A::c 函式發騷了" << endl;
	}
};
int main() {
	void (*fun)(void);//函式指標,其資料型別是void (*)(void)
	A A_demo;
	cout << &A_demo << endl;//輸出的是A_demo物件的首地址
	//(&A_demo)物件首地址
	//*((int *)&A_demo)虛擬函式表首地址
	//(*((int *)(*((int *)&A_demo))))虛擬函式表的第一個函式地址。
	fun = (void(*)(void))(*((int *)(*((int *)&A_demo))));
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)&A_demo)) + 1));
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)&A_demo)) + 2));
	fun();
	system("pause");
	return 0;
}

這裡能夠看出虛擬函式表內的排列是按照public下，函式的定義順序來的。

也就是


2.  在存在繼承關係而且有同名函式時。

class A {
public:
	virtual void a(void) {
		cout << "A::a 函式發騷了" << endl;
	}
	virtual void b(void) {
		cout << "A::b 函式發騷了" << endl;
	}
	virtual void c(void) {
		cout << "A::c 函式發騷了" << endl;
	}
};
class B : public A {
public:
	void a(void) {
		cout << "B::a 函式發騷了" << endl;
	}
};

虛擬函式表內的B::a函式地址覆蓋了本屬於A::a的位置。

3.  存在繼承關係，都是虛擬函式，但是沒有同名時。

//編譯環境Windows 7 VS2015 Update3
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
class A {
public:
	virtual void a(void) {
		cout << "A::a 函式發騷了" << endl;
	}
	virtual void b(void) {
		cout << "A::b 函式發騷了" << endl;
	}
	virtual void c(void) {
		cout << "A::c 函式發騷了" << endl;
	}
};
class B : public A {
public:
	virtual void ab(void) {
		cout << "B::a 函式發騷了" << endl;
	}
	virtual void bb(void) {
		cout << "B::b 函式發騷了" << endl;
	}
	virtual void cb(void) {
		cout << "B::c 函式發騷了" << endl;
	}
};
int main() {
	void (*fun)(void);//函式指標,其資料型別是void (*)(void)
	B B_demo;
	A * pA_demo = &B_demo;
	cout << pA_demo << "," << &B_demo << endl;//輸出的是A_demo物件的首地址
	cout << "pA_demo指向的物件的虛擬函式表首地址: " << (int *)*((int *)pA_demo) << endl;
	/*cout << "&B_demo指向的物件的虛擬函式表首地址: " << (int *)*((int *)&B_demo) + 1 << endl;*/

	//(&A_demo)物件首地址
	//*((int *)&A_demo)虛擬函式表首地址
	//(*((int *)(*((int *)&A_demo))))虛擬函式表的第一個函式地址。
	cout << "派生類的虛擬函式表" << endl;
	fun = (void(*)(void))(*((int *)(*((int *)&B_demo))));
	cout << (*((int *)(*((int *)pA_demo)))) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)&B_demo)) + 1));
	cout << (*((int *)(*((int *)pA_demo)) + 1)) << endl;
	fun();
	
	fun = (void(*)(void))(*((int *)(*((int *)&B_demo)) + 2));
	cout << (*((int *)(*((int *)pA_demo)) + 2)) << endl;
	fun();
	//-----------------------------------------------------------------
	cout << "基類的虛擬函式表" << endl;
	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 3));
	cout << (*((int *)(*((int *)pA_demo)) + 3)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 4));
	cout << (*((int *)(*((int *)pA_demo)) + 4)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 5));
	cout << (*((int *)(*((int *)pA_demo)) + 5)) << endl;
	fun();
	system("pause");
	return 0;
}

這種情況下：在原有的虛擬函式表上，前天三個入口是基類的虛擬函式入口地址。

後三個入口是派生類的虛擬函式入口地址。



1.  多重繼承，但是派生類中有虛擬函式過載的情況。

//編譯環境Windows 7 VS2015 Update3
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
class A {
public:
	virtual void a(void) {
		cout << "A::a 函式發騷了" << endl;
	}
	virtual void b(void) {
		cout << "A::b 函式發騷了" << endl;
	}
	virtual void c(void) {
		cout << "A::c 函式發騷了" << endl;
	}
};
class B {
public:
	virtual void a(void) {
		cout << "B::a 函式發騷了" << endl;
	}
	virtual void b(void) {
		cout << "B::b 函式發騷了" << endl;
	}
	virtual void c(void) {
		cout << "B::c 函式發騷了" << endl;
	}
};
class C :public A,public B{
public:
	virtual void ac(void) {
		cout << "C::a 函式發騷了" << endl;
	}
	virtual void bc(void) {
		cout << "C::b 函式發騷了" << endl;
	}
	virtual void cc(void) {
		cout << "C::c 函式發騷了" << endl;
	}
};

int main() {
	void(*fun)(void);//函式指標,其資料型別是void (*)(void)
	cout << sizeof(long long int) << endl;
	C C_demo;
	A * pA_demo = &C_demo;
	cout << pA_demo << "," << &C_demo << endl;//輸出的是A_demo物件的首地址
	cout << "pA_demo指向的物件的虛擬函式表首地址: " << (int *)*((int *)pA_demo) << endl;
	/*cout << "&B_demo指向的物件的虛擬函式表首地址: " << (int *)*((int *)&B_demo) + 1 << endl;*/
	//(&A_demo)物件首地址
	//*((int *)&A_demo)虛擬函式表首地址
	//(*((int *)(*((int *)&A_demo))))虛擬函式表的第一個函式地址。
	cout << "派生類的虛擬函式表" << endl;
	fun = (void(*)(void))(*((int *)(*((int *)pA_demo))));
	cout << (*((int *)(*((int *)pA_demo)))) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 1));
	cout << (*((int *)(*((int *)pA_demo)) + 1)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 2));
	cout << (*((int *)(*((int *)pA_demo)) + 2)) << endl;
	fun();
	//-----------------------------------------------------------------
	cout << endl;

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 3));
	cout << (*((int *)(*((int *)pA_demo)) + 3)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 4));
	cout << (*((int *)(*((int *)pA_demo)) + 4)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 5));
	cout << (*((int *)(*((int *)pA_demo)) + 5)) << endl;
	fun();

	cout << endl;


	fun = (void(*)(void))(*((int *)(*((int *)pA_demo + 1)) + 0));
	cout << (*((int *)(*((int *)pA_demo + 1)) + 0)) << endl;
	fun();
	
	fun = (void(*)(void))(*((int *)(*((int *)pA_demo + 1)) + 1));
	cout << (*((int *)(*((int *)pA_demo + 1)) + 1)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo + 1)) + 2));
	cout << (*((int *)(*((int *)pA_demo + 1)) + 2)) << endl;
	fun();


	cout << endl;
	/*fun = (void(*)(void))(*((int *)(*((int *)pA_demo + 1)) + 3));
	cout << (*((int *)(*((int *)pA_demo + 1)) + 3)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo + 1)) + 4));
	cout << (*((int *)(*((int *)pA_demo + 1)) + 4)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo + 1)) + 5));
	cout << (*((int *)(*((int *)pA_demo + 1)) + 5)) << endl;
	fun();*/
	system("pause");
	return 0;
}

這裡這種C繼承了A和B的情況下，按照之前的測試方法測試了很久，在虛擬函式表中一直找不到B類的函式入口，我覺得既然繼承了，就應該存在吧，因為畢竟使用了virtual就應該在虛擬函式表裡（這就證明了B類的函式入口應該是在資料區），而且A和B並不存在繼承關係，因為我可以通過C_demo.B::a()這個還是能呼叫到類B的成員函式。

突然，想到會不會有兩張虛擬函式表呢？於是在物件的起始地址那裡向後偏移了4個位元組。發現，這裡也是一張虛擬函式表。

原來一個物件會建立兩張虛擬函式表，現在這種情況的排列形式如下圖。

那為什麼A和C的會在一張表裡面，而不是和B在一起呢？，繼續探知發現，是和C繼承A和B時的順序有關。

改成這樣：class C :publicB,public A {

並且，基類指標改成B的B * pA_demo =&C_demo;（或者直接使用&C_demo是一樣的，同一地址）

結果就變成下面的圖的樣子。


①  問題又來了。如果還是上面那種多繼承，如果A和B類的函式名不相同呢？

沒錯，還是和上面一樣的結果，這裡就證明了，兩個基類的函式名稱相同並不會對編譯產生影響。

②還有一個問題，上面多繼承A和B的情況下，記憶體中出現了兩張表，那麼虛擬函式表的個數是和基類個數有關嗎？

果然，在單層的多繼承的情況下，虛擬函式表的個數是和基類的個數相等的。

③那麼在多重繼承下呢，虛擬函式表個數會和基類個數有什麼關係呢？繼續程式設計測試。（當然這裡測試時，不會使用同名，因為同名會實現派生類的函式入口覆蓋了虛擬函式表中基類的同名虛擬函式入口）這個就是C++裡的覆蓋，隱藏就是派生類的函式與基類同名，於是基類就隱藏了。需要使用：：號去訪問。

測試結果如下圖，


結果顯示只有一張虛擬函式表，而且是以多重繼承的繼承順序排列下來。也就是A->B->C.用語言來描述就是在單純的多重繼承中，虛擬函式表的個數只有一個。並按照繼承的順序成員函式以線性排列在虛擬函式表中。

1.  如果是多繼承中派生類與兩個基類中的一個有過載的情況呢？

測試程式碼如下：

//編譯環境Windows 7 VS2015 Update3
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
class A {
public:
	virtual void a(void) {
		cout << "A::a 函式發騷了" << endl;
	}
	virtual void b(void) {
		cout << "A::b 函式發騷了" << endl;
	}
	virtual void c(void) {
		cout << "A::c 函式發騷了" << endl;
	}
};
class B {
public:
	virtual void ab(void) {
		cout << "B::a 函式發騷了" << endl;
	}
	virtual void bb(void) {
		cout << "B::b 函式發騷了" << endl;
	}
	virtual void cb(void) {
		cout << "B::c 函式發騷了" << endl;
	}
};
class C :public A, public B {
public:
	virtual void a(void) {
		cout << "C::a 函式發騷了" << endl;
	}
	virtual void b(void) {
		cout << "C::b 函式發騷了" << endl;
	}
	virtual void c(void) {
		cout << "C::c 函式發騷了" << endl;
	}
};

int main() {
	void(*fun)(void);//函式指標,其資料型別是void (*)(void)
	cout << sizeof(long long int) << endl;
	C C_demo;
	A * pA_demo = &C_demo;
	cout << pA_demo << "," << &C_demo << endl;//輸出的是A_demo物件的首地址
	cout << "pA_demo指向的物件的虛擬函式表首地址: " << (int *)*((int *)pA_demo) << endl;
	/*cout << "&B_demo指向的物件的虛擬函式表首地址: " << (int *)*((int *)&B_demo) + 1 << endl;*/
	//(&A_demo)物件首地址
	//*((int *)&A_demo)虛擬函式表首地址
	//(*((int *)(*((int *)&A_demo))))虛擬函式表的第一個函式地址。
	cout << "派生類的虛擬函式表" << endl;
	fun = (void(*)(void))(*((int *)(*((int *)pA_demo))));
	cout << (*((int *)(*((int *)pA_demo)))) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 1));
	cout << (*((int *)(*((int *)pA_demo)) + 1)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 2));
	cout << (*((int *)(*((int *)pA_demo)) + 2)) << endl;
	fun();
	//-----------------------------------------------------------------
	/*cout << endl;

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 3));
	cout << (*((int *)(*((int *)pA_demo)) + 3)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 4));
	cout << (*((int *)(*((int *)pA_demo)) + 4)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo)) + 5));
	cout << (*((int *)(*((int *)pA_demo)) + 5)) << endl;
	fun();*/

	cout << endl;


	fun = (void(*)(void))(*((int *)(*((int *)pA_demo + 1)) + 0));
	cout << (*((int *)(*((int *)pA_demo + 1)) + 0)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo + 1)) + 1));
	cout << (*((int *)(*((int *)pA_demo + 1)) + 1)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo + 1)) + 2));
	cout << (*((int *)(*((int *)pA_demo + 1)) + 2)) << endl;
	fun();


	cout << endl;
	/*fun = (void(*)(void))(*((int *)(*((int *)pA_demo + 1)) + 3));
	cout << (*((int *)(*((int *)pA_demo + 1)) + 3)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo + 1)) + 4));
	cout << (*((int *)(*((int *)pA_demo + 1)) + 4)) << endl;
	fun();

	fun = (void(*)(void))(*((int *)(*((int *)pA_demo + 1)) + 5));
	cout << (*((int *)(*((int *)pA_demo + 1)) + 5)) << endl;
	fun();*/
	system("pause");
	return 0;
}

從結果看出，這裡A的虛擬函式的入口被在C類中過載的對應函式將入口覆蓋了。第二張表中是B的函式入口。

1.  如果是多繼承中派生類與兩個基類都有過載的情況呢？u

程式程式碼更改很簡單，直接把B類的函式名字改成和A類相同的。

結果是，A和B這兩個基類給派生類的虛擬函式表，都被派生類C的過載函式覆蓋，這個結果表明，不管有多少個基類存在虛擬函式在派生來中過載，相互之間是沒有任何影響的。

到這裡基本上所有情況我都涉及到了。如有漏情況，或者錯誤，請私聊我，謝謝，本人是菜鳥。可能程式碼寫的並不好，而且部落格書寫也也不好，請諒解。

部落格撰寫者：曾廣

2017/02/24

相關推薦

虛擬函式,純虛擬函式的解釋和內部實現&&虛擬函式表的真實樣子

本篇文章由zg51747708曾廣 原創，未經允許不可以轉載 注：本文章內的程式程式碼全部是在Window 7 sp1  VS2015 Update3上測試 在學習C++中我總體感覺比較難理解的概念就是虛擬函式的理解，而且比較難想到他的內部實現。於是寫下這篇部落格，來幫助大

C++分別用指標和引用實現交換函式

       前幾天上課老師給出了一個課堂作業：請分別用指標和引用來實現兩個數的交換。雖然題目比較俗套，但是好久沒寫過C++程式了，依然很生疏，所以我決定總結一下自己的實現，程式粗糙，風格也混合著C，希望大家給提提建議。        老師出這個題目的目的無非是想讓我們聯絡

友元(友元函式、友元類和友元成員函式) C++

        有些情況下，允許特定的非成員函式訪問一個類的私有成員，同時仍阻止一般的訪問，這是很方便做到的。例如被過載的操作符，如輸入或輸出操作符，經常需要訪問類的私有資料成員。         友元(frend)機制允許一個類將對其非公有成員的訪問權授予指定的函式或者類

訊號的原理和利用--實現sleep函式

訊號就是當一個程序收到一個訊號，程序就要對個訊號作出相關處理，比如我們常用的 kill-9 PID ，這條命令就是向某個程序傳送9號訊號，以終止這個程序，那麼具體到底怎麼實現程序的終止的呢？讓我們一起來看一下。 我們要明白以下三點： 1.程序可以對個訊號作

TTCN3新執行器系列-如何最小化類的成員函式（對拷貝構造和賦值操作函式的反思）

2009年4月份，我們的TTCN3新執行器大體功能已經完成了，於是找了幾個專案來試點應用。 應用效果不太理想，特別是對於5萬行以上的指令碼工程，且包括大asn檔案的情況。 新執行器轉換出來的C++程式碼量很大，特別是由於asn型別很多，導致hpp檔案程式碼量大的編譯速度下降嚴

k-means方法解釋和具體實現

vpd type ros 列數 roi elf 閾值 自動 print k-means方法實現流程：輸入：k, data[n];（1） 選擇k個初始中心點，例如c[0]=data[0],…c[k-1]=data[k-1];（2） 對於data[0]….data[n], 分別

libevent庫的外部和內部實現

一、從大的方面來講libevent的實現就是： 1、往libevent庫裡註冊事件（I/O事件、signal事件、定時器事件） 2、啟動事件迴圈 3、通過I/O複用（select/poll/epoll）來將有就緒事件通知給系統 4、根據相應事件呼叫相應的函式 二、從細節方面來

Activity本質和內部實現機制

今天把Activity全部內容精簡一遍，activity最後一篇！ Activity本質和內部機制 與Activity相關的Framework層類 ActivityThread本質上不是一個執行緒，是一個java類，ActivityThread是所在主執行緒中的一個類，它的

Set去重原理和內部實現

Set可以去重，即不會出現重複元素。 分析 Set去重的原理非常簡單，Set的內部是通過Map來實現的。 我們選取平時常的HashSet來分析 private transient HashMap<E,Object> map; private

jquery.validate.js 和 layer實現漂亮的表單驗證特效

/** * Created by 周前梅 主要用於使用者表單校驗邏輯 顯示on 2017/12/9. */ $(function(){ // 手機號碼驗證 jQuery.validator.addMethod("isMobile", function(value,

C++過載覆蓋和隱藏，虛擬函式與純虛擬函式

這幾個概念都有一個共同點:函式名稱相同,所以不免讓人混淆,大致的區別如下:過載(overload):必須在一個域中,函式名稱相同但是函式引數不同,過載的作用就是同一個函式有不同的行為,因此不是在一個域中的函式是無法構成過載的,這個是過載的重要特徵覆蓋(override):覆

C++ 虛擬函式的內部實現

單繼承的情況下 若類有虛擬函式，則在建構函式的時候編譯器會自動為類的例項（物件）在其記憶體的首部（0地址偏移處）增添一個虛擬函式表指標vfptr，指向該類的虛擬函式表。虛擬函式表中會存放該類所有的虛擬函式地址，普通函式則不會被放入其中。如果是子類重寫了父類的虛擬函式，那麼在建立虛擬函

C++中的虛擬函式與靜態聯編和動態聯編

          程式在呼叫函式時，將使用哪個可執行程式碼塊呢？編譯器負責回答這個問題，將原始碼中的函式呼叫解釋為執行特定的函式程式碼塊被稱為函式名聯編。在C中，因為每個函式名都對應一個不同的函式，而在C++中，由於函式過載的緣故，編譯器必須檢視函式引數以及函式名才能確定

淺析C++中虛擬函式的呼叫及物件的內部佈局

     在我那篇《淺析C++中的this指標》中，我通過分析C++程式碼編譯後生成的彙編程式碼來分析this指標的實現方法。這次我依然用分析C++程式碼編譯後生成的彙編程式碼來說明C++中虛擬函式呼叫的實現方法，順便也說明一下C++中的物件內部佈局。下面所有的彙編程式碼都是

C++學習之多型篇（虛擬函式和虛解構函式的實現原理--虛擬函式表）

通過下面的程式碼來說明： #include <iostream> #include <stdlib.h> #include <string> using namespace std; /**  *  定義動物類：Animal  *  成員

C++學習:虛擬函式,純虛擬函式(virtual),虛繼承,虛解構函式

C++學習:虛擬函式,虛繼承,純虛擬函式(virtual)虛解構函式 虛擬函式 純虛擬函式 虛解構函式 虛繼承 簡介 在java這種高階語言中,有abstract和interface這兩個關鍵字.代表的是抽象類和介面,但是在C++這門語言中

虛擬函式/純虛擬函式，以及建構函式不能是虛擬函式原因

1.首先要了解什麼是虛擬函式：      簡單地說，那些被virtual關鍵字修飾的成員函式，就是虛擬函式（實現多型）。          作用：指向基類的指標在操作它的多型類物件時，會根據不同的類物

c++中的 虛擬函式 純虛擬函式 虛基類

虛擬函式 ，純虛擬函式， 虛基類，它們都和virtual有關，這三個帶有虛字的定義容易使人混淆，下面先從作用上來解釋這三個定義的區別： 1.虛擬函式是用於多型中virtual修飾父類函式，確保父類指標呼叫子類物件時，執行子類函式的。 2.純虛擬函式是用來定義介面的

C++中的動態型別與動態繫結、虛擬函式、執行時多型的實現【轉】

（轉自：https://blog.csdn.net/iicy266/article/details/11906509） 動態型別與靜態型別 靜態型別          是指不需要考慮表示式的執行期語

C++函式中那些不可以被宣告為虛擬函式的函式

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！