C++物件的記憶體佈局（上)

阿新 • • 發佈：2018-12-15

1 前言

檢視本文之前最好先看這篇文章：

07年12月，我寫了一篇《C++ 虛擬函式表解析》的文章，引起了大家的興趣。有很多朋友對我的文章留了言，有鼓勵我的，有批評我的，還有很多問問題的。我在這裡一併對大家的留言表示感謝。這也是我為什麼再寫一篇續言的原因。因為，在上一篇文章中，我用了的示例都是非常簡單的，主要是為了說明一些機理上的問題，也是為了圖一些表達上方便和簡單。不想，這篇文章成為了開啟C++物件模型記憶體佈局的一個引子，引發了大家對C++物件的更深層次的討論。當然，我之前的文章還有很多方面沒有涉及，從我個人感覺下來，在談論虛擬函式表裡，至少有以下這些內容沒有涉及：

1）有成員變數的情況。

2）有重複繼承的情況。

3）有虛擬繼承的情況。

4）有鑽石型虛擬繼承的情況。

這些都是我本篇文章需要向大家說明的東西。所以，這篇文章將會是《C++ 虛擬函式表解析》的一個續篇，也是一篇高階進階的文章。我希望大家在讀這篇文章之前對C++有一定的基礎和了解，並能先讀我的上一篇文章。因為這篇文章的深度可能會比較深，而且會比較雜亂，我希望你在讀本篇文章時不會有大腦思維紊亂導致大腦宕機的情況。?

物件的影響因素

簡而言之，我們一個類可能會有如下的影響因素：

1）成員變數

2）虛擬函式（產生虛擬函式表）

3）單一繼承（只繼承於一個類）

4）多繼承（繼承多個類）

5）重複繼承（繼承的多個父類中其父類有相同的超類）

6）虛擬繼承（使用virtual方式繼承，為了保證繼承後父類的記憶體佈局只會存在一份）

上述的東西通常是C++這門語言在語義方面對物件內部的影響因素，當然，還會有編譯器的影響（比如優化），還有位元組對齊的影響（位元組對齊可參考：位元組對齊）。在這裡我們都不討論，我們只討論C++語言上的影響。

本篇文章著重討論下述幾個情況下的C++物件的記憶體佈局情況。

1）單一的一般繼承（帶成員變數、虛擬函式、虛擬函式覆蓋）

2）單一的虛擬繼承（帶成員變數、虛擬函式、虛擬函式覆蓋）

3）多繼承（帶成員變數、虛擬函式、虛擬函式覆蓋）

4）重複多繼承（帶成員變數、虛擬函式、虛擬函式覆蓋）

5）鑽石型的虛擬多繼承

（帶成員變數、虛擬函式、虛擬函式覆蓋）

我們的目標就是，讓事情越來越複雜。

知識複習

我們簡單地複習一下，我們可以通過物件的地址來取得虛擬函式表的地址，如：

typedef void(*Fun)(void);
 
Base b;
 
Fun pFun = NULL;
 
cout << "虛擬函式表地址：" << (int*)*(int*)(&b) << endl;
 
cout << "虛擬函式表 — 第一個函式地址：" << (int*)*(int*)*(int*)(&b) << endl;
 
 
// Invoke(呼叫) the first virtual function 
 
pFun = (Fun)*((int*)*(int*)(&b));
 
pFun();

我們同樣可以用這種方式來取得整個物件例項的記憶體佈局。因為這些東西在記憶體中都是連續分佈的，我們只需要使用適當的地址偏移量，我們就可以獲得整個記憶體物件的佈局。

本篇文章中的例程或記憶體佈局主要使用如下編譯器和系統：

1）Windows XP 和 VC++ 2003

2）Cygwin 和 G++ 3.4.4

2 單一的一般繼承（多重繼承）

下面，我們假設有如下所示的一個繼承關係：

在這裡插入圖片描述

請注意，在這個繼承關係中，父類，子類，孫子類都有自己的一個成員變數。而子類覆蓋了父類的f()方法，孫子類覆蓋了子類的g_child()及其超類的f()。

我們的源程式如下所示：

#include <iostream>
using namespace std;
 
class Parent {
public:
	int iparent;
	Parent() :iparent(10) {}
	virtual void f() { cout << " Parent::f()" << endl; }
	virtual void g() { cout << " Parent::g()" << endl; }
	virtual void h() { cout << " Parent::h()" << endl; }
};
 
 
class Child : public Parent {
public:
	int ichild;
	Child() :ichild(100) {}
	virtual void f() { cout << "Child::f()" << endl; }
	virtual void g_child() { cout << "Child::g_child()" << endl; }
	virtual void h_child() { cout << "Child::h_child()" << endl; }
};
 
class GrandChild : public Child {
public:
	int igrandchild;
	GrandChild() :igrandchild(1000) {}
	virtual void f() { cout << "GrandChild::f()" << endl; }
	virtual void g_child() { cout << "GrandChild::g_child()" << endl; }
	virtual void h_grandchild() { cout << "GrandChild::h_grandchild()" << endl; }
};

我們使用以下程式作為測試程式：（下面程式中，我使用了一個int** pVtab 來作為遍歷物件記憶體佈局的指標，這樣，我就可以方便地像使用陣列一樣來遍歷所有的成員包括其虛擬函式表了，在後面的程式中，我也是用這樣的方法的，請不必感到奇怪，）

int main()
{
	typedef void(*Fun)(void);
	GrandChild gc;
	int** pVtab = (int**)&gc;
	Fun pFun = NULL;
 
	cout << "[0] GrandChild::_vptr->" << endl;
	for (int i = 0; (Fun)pVtab[0][i] != NULL; i++) {
		pFun = (Fun)pVtab[0][i];
		cout << "    [" << i << "] ";
		pFun();
	}
 
	cout << "[1] Parent.iparent = " << (int)pVtab[1] << endl;
	cout << "[2] Child.ichild = " << (int)pVtab[2] << endl;
	cout << "[3] GrandChild.igrandchild = " << (int)pVtab[3] << endl;
 
	return 0;
}

其執行結果如下所示：（在VC++ 2003和G++ 3.4.4下）

[0] GrandChild::_vptr->
    [0] GrandChild::f()
    [1] Parent::g()
    [2] Parent::h()
    [3] GrandChild::g_child()
    [4] Child::h1()
    [5] GrandChild::h_grandchild()
[1] Parent.iparent = 10
[2] Child.ichild = 100
[3] GrandChild.igrandchild = 1000

使用圖片表示如下：

在這裡插入圖片描述

可見以下幾個方面：

1）虛擬函式表在最前面的位置。

2）成員變數根據其繼承和宣告順序依次放在後面。

3）在單一的繼承中，被overwrite的虛擬函式在虛擬函式表中得到了更新。

3 多繼承

下面，再讓我們來看看多繼承中的情況，假設有下面這樣一個類的繼承關係。注意：子類只overwrite了父類的f()函式，而還有一個是自己的函式（我們這樣做的目的是為了用g1()作為一個標記來標明子類的虛擬函式表）。而且每個類中都有一個自己的成員變數：

在這裡插入圖片描述

我們的類繼承的原始碼如下所示：父類的成員初始為10，20，30，子類的為100

#include <iostream>
using namespace std;
 
class Base1 {
public:
	int ibase1;
	Base1() :ibase1(10) {}
	virtual void f() { cout << "Base1::f()" << endl; }
	virtual void g() { cout << "Base1::g()" << endl; }
	virtual void h() { cout << "Base1::h()" << endl; }
};
 
class Base2 {
public:
	int ibase2;
	Base2() :ibase2(20) {}
	virtual void f() { cout << "Base2::f()" << endl; }
	virtual void g() { cout << "Base2::g()" << endl; }
	virtual void h() { cout << "Base2::h()" << endl; }
};
 
class Base3 {
public:
	int ibase3;
	Base3() :ibase3(30) {}
	virtual void f() { cout << "Base3::f()" << endl; }
	virtual void g() { cout << "Base3::g()" << endl; }
	virtual void h() { cout << "Base3::h()" << endl; }
};
 
class Derive : public Base1, public Base2, public Base3 {
public:
	int iderive;
	Derive() :iderive(100) {}
	virtual void f() { cout << "Derive::f()" << endl; }
	virtual void g1() { cout << "Derive::g1()" << endl; }
};

我們通過下面的程式來檢視子類例項的記憶體佈局：下面程式中，注意我使用了一個s變數，其中用到了sizof(Base)來找下一個類的偏移量。（因為我宣告的是int成員，所以是4個位元組，所以沒有對齊問題。關於記憶體的對齊問題，大家可以自行試驗，我在這裡就不多說了）

int main()
{
	typedef void(*Fun)(void);
	Derive d;
	int** pVtab = (int**)&d;
	Fun pFun = NULL;
 
	cout << "[0] Base1::_vptr->" << endl;
	pFun = (Fun)pVtab[0][0];
	cout << "     [0] ";
	pFun();
	pFun = (Fun)pVtab[0][1];
	cout << "     [1] ";
	pFun();
	pFun = (Fun)pVtab[0][2];
	cout << "     [2] ";
	pFun();
	pFun = (Fun)pVtab[0][3];
	cout << "     [3] ";
	pFun();
	pFun = (Fun)pVtab[0][4];
	cout << "     [4] "; 
    cout << pFun << endl;
	cout << "[1] Base1.ibase1 = " << (int)pVtab[1] << endl;
	int s = sizeof(Base1) / 4;
	cout << "[" << s << "] Base2::_vptr->" << endl;
	pFun = (Fun)pVtab[s][0];
	cout << "     [0] "; 
	pFun();
	pFun = (Fun)pVtab[s][1];
	cout << "     [1] "; 
	pFun();
	pFun = (Fun)pVtab[s][2];
	cout << "     [2] "; 
	pFun();
	pFun = (Fun)pVtab[s][3];
	cout << "     [3] ";
	cout << pFun << endl;
 
	cout << "[" << s + 1 << "] Base2.ibase2 = " << (int)pVtab[s + 1] << endl;
 
	s = s + sizeof(Base2) / 4;
 
	cout << "[" << s << "] Base3::_vptr->" << endl;
 
	pFun = (Fun)pVtab[s][0];
	cout << "     [0] "; 
	pFun();
	pFun = (Fun)pVtab[s][1];
	cout << "     [1] "; 
	pFun();
	pFun = (Fun)pVtab[s][2];
	cout << "     [2] "; 
	pFun();
 
	pFun = (Fun)pVtab[s][3];
	cout << "     [3] ";
	cout << pFun << endl;
	s++;
	cout << "[" << s << "] Base3.ibase3 = " << (int)pVtab[s] << endl;
	s++;
	cout << "[" << s << "] Derive.iderive = " << (int)pVtab[s] << endl;
 
	return 0;
}

其執行結果如下所示：（在VC++ 2015和G++ 3.4.4下）VC建議清理下工程再編譯。

[0] Base1::_vptr->
     [0] Derive::f()
     [1] Base1::g()
     [2] Base1::h()
     [3] Driver::g1()
     [4] 00000000      注意：在GCC下，這裡是1
[1] Base1.ibase1 = 10
[2] Base2::_vptr->
     [0] Derive::f()
     [1] Base2::g()
     [2] Base2::h()
     [3] 00000000      注意：在GCC下，這裡是1
[3] Base2.ibase2 = 20
[4] Base3::_vptr->
     [0] Derive::f()
     [1] Base3::g()
     [2] Base3::h()
     [3] 00000000
[5] Base3.ibase3 = 30
[6] Derive.iderive = 100

使用圖片表示是下面這個樣子：

在這裡插入圖片描述

（注：圖中有誤：Derive::Base3中[1]應為Base3::g()，[2]應為Base3::h()）

我們可以看到：

1）每個父類都有自己的虛表。

2）子類的成員函式被放到了第一個父類的表中。

3）記憶體佈局中，其父類佈局依次按宣告順序排列。

4）每個父類的虛表中的f()函式都被overwrite成了子類的f()。這樣做就是為了解決不同的父類型別的指標指向同一個子類例項，而能夠呼叫到實際的函式。

例：

#include <iostream>
using namespace std;
 
class Base1 {
public:
	int ibase1;
	Base1() :ibase1(10) {}
	virtual void f() { cout << "Base1::f()" << endl; }
	virtual void g() { cout << "Base1::g()" << endl; }
	virtual void h() { cout << "Base1::h()" << endl; }
};
 
class Base2 {
public:
	int ibase2;
	Base2() :ibase2(20) {}
	virtual void f() { cout << "Base2::f()" << endl; }
	virtual void g() { cout << "Base2::g()" << endl; }
	virtual void h() { cout << "Base2::h()" << endl; }
};
 
class Base3 {
public:
	int ibase3;
	Base3() :ibase3(30) {}
	virtual void f() { cout << "Base3::f()" << endl; }
	virtual void g() { cout << "Base3::g()" << endl; }
	virtual void h() { cout << "Base3::h()" << endl; }
};
 
class Derive : public Base1, public Base2, public Base3 {
public:
	int iderive;
	Derive() :iderive(100) {}
	virtual void f() { cout << "Derive::f()" << endl; }
	virtual void g1() { cout << "Derive::g1()" << endl; }
};
 
 
int main()
{
	Derive d;
	Base3 *p = &d;
	d.f();  // OK
	d.g1(); // OK
	// d.g(); 不明確報錯
	//d.h(); 不明確報錯
 
	return 0;
}

此文章轉載自：

C++物件的記憶體佈局（上)

1 前言

2 單一的一般繼承（多重繼承）

3 多繼承

C++物件的記憶體佈局（上)

C++ 物件的記憶體佈局（上）

陳皓-C++ 物件的記憶體佈局（上）：筆記

C++筆記第五十課 C++物件模型分析（上）---狄泰學院

c++物件記憶體佈局模型

C++物件記憶體佈局

C++物件模型之記憶體佈局（3）

C++物件模型之記憶體佈局（2）

C++物件模型之記憶體佈局（1）

C++中物件的記憶體佈局（一）

C++物件記憶體模型2 （虛擬函式，虛指標，虛擬函式表）

C++筆記第十七課物件的構造（上）---狄泰學院

C++面向物件高階程式設計（上）第二週侯捷

C++面向物件高階程式設計（上）第一週侯捷

侯捷 C++面向物件高階開發（上）筆記整理

C++面向物件高階程式設計（上）第三週侯捷類與類之間的關係

C++ 下 Function 物件的實現（上）

【C++】c++單繼承、多繼承、菱形繼承記憶體佈局（虛擬函式表結構）

c++單繼承、多繼承、菱形繼承的記憶體佈局（虛擬函式表結構）

圖說C++物件模型：物件記憶體佈局詳解

C++物件的記憶體佈局（上)

1 前言

2 單一的一般繼承（多重繼承）

3 多繼承

相關推薦