C++ 虛擬函式 獲取C++虛表地址和虛擬函式地址
學過C++的應該都對虛表有所耳聞，在此就不過多介紹概念了，通過實
例來演示一下如何獲取虛表地址和虛擬函式地址。
簡單說一下虛表的概念：在一個類中如果有虛擬函式，那麼此類的例項中就有
一個虛表指標指向虛表，這個虛表是一塊兒專門存放類的虛擬函式地址的記憶體。
圖示說明本文的主題(先看圖更容易後面程式碼中的指標操作)：
程式碼如下(要講解的都在程式碼的註釋中說明了)：
class Base { public: virtual void f() { cout << "Base::f" << endl; } virtual void g() { cout << "Base::g" << endl; } void h() { cout << "Base::h" << endl; } }; typedef void(*Fun)(void); //函式指標 int main() { Base b; // 這裡指標操作比較混亂,在此稍微解析下: // *****printf("虛表地址:%p\n", *(int *)&b); 解析*****: // 1.&b代表物件b的起始地址 // 2.(int *)&b 強轉成int *型別,為了後面取b物件的前四個位元組,前四個位元組是虛表指標 // 3.*(int *)&b 取前四個位元組,即vptr虛表地址 // // *****printf("第一個虛擬函式地址:%p\n", *(int *)*(int *)&b);*****: // 根據上面的解析我們知道*(int *)&b是vptr,即虛表指標.並且虛表是存放虛擬函式指標的 // 所以虛表中每個元素(虛擬函式指標)在32位編譯器下是4個位元組,因此(int *)*(int *)&b // 這樣強轉後為了後面的取四個位元組.所以*(int *)*(int *)&b就是虛表的第一個元素. // 即f()的地址. // 那麼接下來的取第二個虛擬函式地址也就依次類推. 始終記著vptr指向的是一塊記憶體, // 這塊記憶體存放著虛擬函式地址,這塊記憶體就是我們所說的虛表. // printf("虛表地址:%p\n", *(int *)&b); printf("第一個虛擬函式地址:%p\n", *(int *)*(int *)&b); printf("第二個虛擬函式地址:%p\n", *((int *)*(int *)(&b) + 1)); Fun pfun = (Fun)*((int *)*(int *)(&b)); //vitural f(); printf("f():%p\n", pfun); pfun(); pfun = (Fun)(*((int *)*(int *)(&b) + 1)); //vitural g(); printf("g():%p\n", pfun); pfun(); }
--------------------------------------------------------------------------------------------------------------------------------
虛擬函式
虛擬函式就是用virtual來修飾的函式。虛擬函式是實現C++多型的基礎。
虛表
每個類都會為自己類的虛擬函式建立一個表，來存放類內部的虛擬函式成員。
虛擬函式表指標
每個類在建構函式裡面進行虛表和虛表指標的初始化。
下面看一段程式碼：
// // main.cpp // VirtualTable // // Created by Alps on 15/4/14. // Copyright (c) 2015年 chen. All rights reserved. // #include <iostream> using namespace std; class Base{ public: virtual void func(){ printf("Base\n"); } virtual void hunc(){ printf("HBase\n"); } private: virtual void gunc(){ printf("Base Private\n"); } }; class Derive: public Base{ public: virtual void func(){ printf("Derive\n"); } }; class DeriveSecond: public Base{ public: void func(){ printf("Second!\n"); } }; class DeriveThird: public Base{ }; class DeriveForth: public Base{ public: void gunc(){ printf("Derive Forth\n"); } }; int main(int argc, const char * argv[]) { Derive d; Base *pb = &d; pb->func(); // 1 輸出：Derive DeriveSecond sec; pb = &sec; pb->func(); // 2 輸出：Derive Second DeriveThird thi; pb = &thi; pb->func(); //3 輸出：Base DeriveForth forth; pb = &forth; // pb->gunc(); // 4 報錯 return 0; }
在這個裡面我建立了一個基類Base還有其他派生類。
首先
// 1部分，表示了雖然我們宣告的是一個Base類的指標，但是指向的是派生類的例項，所以呼叫的就是派生類的函式。其次
// 2部分，表示的和1差不多，只不過在// 2裡不是虛函數了，覆蓋了父類的虛擬函式。但還是存放在派生類的虛表裡。在
// 3的程式碼裡可以看到，派生類沒有覆蓋父類的虛擬函式的時候，雖然指向的是派生類的例項，但是呼叫的是父類的方法，是因為在繼承時候，子類也有一個虛表，裡面存放了父類的虛擬函式表。在
// 4裡是私有的虛擬函式是不能直接被外部呼叫的。
虛表詳解
先看如下程式碼：程式碼來源：RednaxelaFX，程式語言廚此人我覺得很厲害，這裡借用一下他的程式碼，無任何商用，如果有問題，請聯絡我刪除。
#include <string>
#include <iostream>
class Object {
int identity_hash_;
public:
Object(): identity_hash_(std::rand()) { }
int IdentityHashCode() const { return identity_hash_; }
virtual int HashCode() { return IdentityHashCode(); }
virtual bool Equals(Object* rhs) { return this == rhs; }
virtual std::string ToString() { return "Object"; }
};
class MyObject : public Object {
int dummy_;
public:
int HashCode() override { return 0; }
std::string ToString() override { return "MyObject"; }
};
int main() {
Object o1;
MyObject o2;
std::cout << o2.ToString() << std::endl
<< o2.IdentityHashCode() << std::endl
<< o2.HashCode() << std::endl;
}
/*
Object vtable
-16 [ offset to top ] __si_class_type_info
-8 [ typeinfo Object ] --> +0 [ ... ]
--> +0 [ vptr ] --> +0 [ &Object::HashCode ]
+8 [ identity_hash_ ] +8 [ &Object::Equals ]
+12 [ (padding) ] +16 [ &Object::ToString ]
MyObject vtable
-16 [ offset to top ] __si_class_type_info
-8 [ typeinfo MyObject ] --> +0 [ ... ]
--> +0 [ vptr ] --> +0 [ &MyObject::HashCode ]
+8 [ identity_hash_ ] +8 [ &Object::Equals ]
+12 [ dummy_ ] +16 [ &MyObject::ToString ]
*/這裡最主要的是我認為R大的這個虛表畫的實在是好看。所以直接借用了，一看就比我上面自己寫的程式碼好看多了(T T)。
首先我們學習的時候，可以暫時先無視小於0的虛表內容。從+0開始存放了vptr這個虛表指標指向了類的虛表。可以很清楚的看到在MyObject的虛表裡其中HashCode 和 ToString函式已經是派生類的虛函數了，把父類的函式重寫了。
所以這兩個R大畫的類已經很清楚的說明了類的虛表虛擬函式的操作。
那麼有沒有比較暴力的辦法強行自己來控制虛表呢。其實這個來源於當時我做的一個阿里筆試題，做完當天我就看到知乎的R大已經做了詳細的解釋，這裡還是引用他的程式碼好了。
虛表和虛擬函式地址
#include <iostream>
using namespace std;
class animal
{
protected:
int age_;
animal(int age): age_(age) { }
public:
virtual void print_age(void) = 0;
virtual void print_kind() = 0;
virtual void print_status() = 0;
};
class dog : public animal
{
public:
dog(): animal(2) { }
~dog() { }
virtual void print_age(void) {
cout << "Woof, my age = " << age_ << endl;
}
virtual void print_kind() {
cout << "I'm a dog" << endl;
}
virtual void print_status() {
cout << "I'm barking" << endl;
}
};
class cat : public animal
{
public:
cat(): animal(1) { }
~cat() { }
virtual void print_age(void) {
cout << "Meow, my age = " << age_ << endl;
}
virtual void print_kind() {
cout << "I'm a cat" << endl;
}
virtual void print_status() {
cout << "I'm sleeping" << endl;
}
};
void print_random_message(void* something) {
cout << "I'm crazy" << endl;
}
int main(void)
{
cat kitty;
dog puppy;
animal* pa = &kitty;
intptr_t* cat_vptr = *((intptr_t**)(&kitty));
intptr_t* dog_vptr = *((intptr_t**)(&puppy));
intptr_t fake_vtable[] = {
dog_vptr[0], // for dog::print_age
cat_vptr[1], // for cat::print_kind
(intptr_t) print_random_message
};
*((intptr_t**) pa) = fake_vtable;
pa->print_age(); // Woof, my age = 1
pa->print_kind(); // I'm a cat
pa->print_status(); // I'm crazy
return 0;
}我們可以看到R大幹了什麼！！喪心病狂的把vtable自己偽造了一個，然後放到虛表指標後面！簡直佩服。看到這個程式碼我也是才明白，虛表可以這麼操作。
虛表地址和虛擬函式地址
虛擬函式表的地址（int*）&classname)與虛擬函式的地址（int*）*(int*)(&classname)實際按照R大的說法，這裡的int應該改成intptr_t才更好，這樣能夠防止在LP64模型下，函式指標是8個位元組。而地址獲取不全。
虛擬函式表的地址和虛擬函式地址的關係類似於： x 和 *x的關係。