目錄 一.前言 二.OpenGL ES 上下文 三.OpenGL ES 狀態機 四.緩存 五.渲染 六.紋理 七.光柵化 Rasterization 八.片元著色器 九.頂點著色器 十.著⾊語言 GLSL 十一.著色器使用流程 十二.著色器的渲染流程 十三.猜你喜歡 零基礎 OpenGL ES 學習 ...
上一篇博客《C++對象模型：g++實現（一）》用我的理解總結了在無繼承體系下g++實現的C++對象的記憶體佈局，這篇就來總結一下在有繼承情況下的C++對象的記憶體佈局。
本文中所有代碼均可從這裡拿到（百度網盤）。
有繼承情況下的C++對象的記憶體佈局
C++是支持多繼承的，而多繼承可能就會出現繼承的兩個（或多個）類有公共的父類，為了防止在一個對象中出現多個公共父類的實體，C++就提出了虛繼承。因此總的來說C++的繼承有兩種：無虛繼承和有虛繼承。
無虛繼承
在無虛繼承情況下，無論是public繼承還是protected、private繼承，其記憶體佈局都是一樣的，因此這裡只提供public繼承的例子。
所有的基類和派生類都沒有虛函數
在這種情況下，其實就相當於構造了一個對象，其內部按基類的聲明順序添加了各個基類對象，最後再添加派生類自己的對象，其對齊要求和類作為（非靜態）成員變數是一樣的。
// test09.cpp
#include <cstdio>
class Base1 {
public:
Base1(int i, char c)
:m_i(i), m_c(c)
{}
private: // 在Deriverd中：
int m_i; // Offset: 0
char m_c; // Offset: 4
}; // size: 8
class Base2{
public:
Base2(short s, int i)
: m_s(s), m_i(i) {}
private: // 在Deriverd中：
short m_s; // Offset: 8
int m_i; // Offset: 10
}; // size: 8
class Derived: public Base1, public Base2 {
public:
Derived(int i1, char c, short s, int i2, long l)
: Base1(i1, c), Base2(s, i2), m_l(l)
{}
long getLong() const { return m_l; }
private:
long m_l; // Offset: 16
}; // size: 8 + 8 + 8 = 24
int main() {
std::printf("sizeof Derived: %d\n", static_cast<int>(sizeof(Derived)));
Derived d(1, static_cast<char>(2), static_cast<short>(3), 4, static_cast<long>(5));
long l = d.getLong();
}
// Output:
// sizeof Derived: 24
使用gdb調試，查看記憶體佈局，如下：
如果不是按基類整體作為一個（非靜態）成員變數的話，Base2::m_s的offset應為6，但實際上其offset為8，因為Base2的對齊要求為4。
基類無虛函數，派生類有虛函數
這個也很簡單，只需要在整個類的頭部安插一個虛表指針vptr即可。
// test10.cpp
// 只是令Derived::getLong()為虛函數
#include <cstdio>
class Base1 {
public:
Base1(int i, char c)
:m_i(i), m_c(c)
{}
private: // 在Deriverd中：
int m_i; // Offset: 0
char m_c; // Offset: 4
}; // size: 8
class Base2{
public:
Base2(short s, int i)
: m_s(s), m_i(i) {}
private: // 在Deriverd中：
short m_s; // Offset: 8
int m_i; // Offset: 10
}; // size: 8
class Derived: public Base1, public Base2 {
public:
Derived(int i1, char c, short s, int i2, long l)
: Base1(i1, c), Base2(s, i2), m_l(l)
{}
virtual // 僅在此有改動
long getLong() const { return m_l; }
private:
long m_l; // Offset: 16
}; // size: 8 + 8 + 8 = 24
int main() {
std::printf("sizeof Derived: %d\n", static_cast<int>(sizeof(Derived)));
Derived d(1, static_cast<char>(2), static_cast<short>(3), 4, static_cast<long>(5));
long l = d.getLong();
}
// Output:
// sizeof Derived: 32
基類也有虛函數
在這種情況下，派生類會繼承基類的虛函數，也會復用基類放置虛表指針的記憶體位置，無論基類有沒有定義虛函數，有沒有新增虛函數，都不會增加新的虛表指針，而是復用基類的虛表指針的記憶體位置。
// test11.cpp
// 添加了：
// virtual char Base1::getChar();
// int Base1::getIntOfBase1();
// virtual char Base2::getShort();
// int Base2::getIntOfBase2();
// virtual int Derived::getInt();
#include <cstdio>
class Base1 {
public:
Base1(int i, char c)
:m_i(i), m_c(c)
{}
virtual
char getChar() const { return m_c; } // ! 添加
int getIntOfBase1() const { return m_i; } // ! 添加
private:
int m_i;
char m_c;
};
class Base2{
public:
Base2(short s, int i)
: m_s(s), m_i(i) {}
virtual
short getShort() const { return m_s; } // ! 添加
int getIntOfBase2() const { return m_i; } // ! 添加
private:
short m_s;
int m_i;
};
class Derived: public Base1, public Base2 {
public:
Derived(int i1, char c, short s, int i2, long l)
: Base1(i1, c), Base2(s, i2), m_l(l)
{}
virtual
long getLong() const { return m_l; }
virtual
int getInt() { return getIntOfBase2(); } // ! 添加
private:
long m_l;
};
int main() {
std::printf("sizeof Derived: %d\n", static_cast<int>(sizeof(Derived)));
Derived d(1, static_cast<char>(2), static_cast<short>(3), 4, static_cast<long>(5));
auto c = d.getChar();
auto s = d.getShort();
auto i = d.getInt();
}
// Output:
// sizeof Derived: 40
使用gdb調試編譯出來的程式，如下：
我們可以看到只有兩個虛函數表，是繼承自Base1和Base2的。
我們再看一下這兩個虛函數表裡面的內容：
可以看到Base1的虛表裡面，Base1::vptr[0]為Base1::getChar()的地址，Base1::vptr[2]為Derived::getInt()的地址；在Base2的虛表裡面，Base2::vptr[0]為Base2::getShort()的地址。
那Base1::vptr[1]是什麼地址？我們現在還沒有看到Derived::getLong()這個虛函數，是它的地址嗎？查看該地址處的反彙編代碼可知，確實如此。
至此，我們可以總結在基類有虛函數的時候C++的記憶體佈局了：派生類新增的虛函數並不會導致新的虛表指針的誕生，而是會復用第一個虛表指針，使其指向一個新的虛表，這個虛表前幾項都是基類的虛函數地址（當然，如果派生類覆寫[override]了該虛函數，新的虛函數地址會在該位置覆蓋基類的虛函數地址），後面則是派生類的虛函數地址。
指針的調整
為了支持多態，C++支持將派生類的指針賦值給基類的指針，那C++是如何保證這個指針能正確索引到成員變數和成員函數的呢？
其實很簡單，在派生類中，有著完整的基類對象，包括基類的虛函數指針，而且虛函數表中的虛函數地址也已經被正確設置，因此只需要把指針調整到該基類對應的位置即可。如：
// file test12.cpp
#include <cstdio>
class Base1 {
public:
Base1(int i, char c)
:m_i(i), m_c(c)
{}
virtual
char getChar() const { return m_c; }
int getIntOfBase1() const { return m_i; }
private:
int m_i;
char m_c;
};
class Base2{
public:
Base2(short s, int i)
: m_s(s), m_i(i) {}
virtual
short getShort() const { return m_s; }
int getIntOfBase2() const { return m_i; }
private:
short m_s;
int m_i;
};
class Derived: public Base1, public Base2 {
public:
Derived(int i1, char c, short s, int i2, long l)
: Base1(i1, c), Base2(s, i2), m_l(l)
{}
virtual
long getLong() const { return m_l; }
virtual
int getInt() { return getIntOfBase2(); }
private:
long m_l;
};
int main() {
Derived d(1, static_cast<char>(2), static_cast<short>(3), 4, static_cast<long>(5));
Derived* pd = &d;
// Base1 在Derived類開頭，不需要調整指針
Base1* pb1 = pd;
// Base2 在Derived類0x10偏移處，
// pb2 = (pd == nullptr ? nullptr : pd + 0x10)
Base2* pb2 = pd;
}
反彙編正如註釋：
有虛繼承
按照《深度探索C++對象模型》的描述，對於有虛繼承的類，會有一個偏移量值表徵當前指針與虛基類基址距離的偏移量。那麼這個偏移量在哪裡？在對象實例的記憶體佈局中？還是在虛表裡面？如果在虛表裡面會不會添加新的虛表指針？還是繼續復用基類的虛表指針？
// test13.cpp
class Point2D {
public:
Point2D(int x, int y)
: m_x(x), m_y(y)
{}
virtual
int getX() const { return m_x; }
private:
int m_x;
int m_y;
};
class Point3D: virtual public Point2D {
public:
Point3D(int x, int y, int z)
: Point2D(x, y), m_z(z)
{}
virtual
int getZ() { return m_z; }
private:
int m_z;
};
class VertexInterface {
public:
virtual
VertexInterface* getNext() = 0;
};
class Vertex: virtual public Point2D, public VertexInterface {
public:
Vertex(int x, int y, Vertex* next)
: Point2D(x, y), m_next(next)
{}
virtual
Vertex* getNext() override { return m_next; }
private:
Vertex* m_next;
};
class Vertex3D: public Point3D, public Vertex {
public:
Vertex3D(int x, int y ,int z, int mumble)
: Point3D(x, y, z),
Vertex(x, y, nullptr),
Point2D(x, y)，
m_mumble(mumble)
{}
virtual
long getMumble()
{ return m_mumble; }
private:
int m_mumble;
};
int main() {
Point3D p3d(1,2,3);
Point3D* pp3d = &p3d;
Point2D* pp2d = pp3d;
Vertex vex(1, 2, nullptr);
Vertex* next = vex.getNext();
Vertex3D v3d(1, 2, 3, 4);
Vertex3D* pv3d = &v3d;
Point2D* pp2d_1 = pv3d;
int mumble = v3d.getMumble();
}
派生類的所有非虛基類里都沒有虛表指針
對上面代碼生成的程式使用gdb進行調試。
首先查看各個類對象的size。
我們可以看到，Point2D的size為16，這是可以預見的，虛表指針vptr占用8個位元組，兩個int類型的非static成員變數占用8個位元組，一共16個位元組。
而Point3D的size為32，虛基類Point2D的size為16，對齊要求為8，自己的一個int類型的非static成員變數占用4個位元組，如果沒有新添加東西，則加上對齊要求則只需要24位元組size，說明必然加了新的東西，要麼是基類offset，要麼是新的虛表指針。
可以看到虛基類Point2D被放在了offset0x10的位置，而Point3D::m_z在offset0x8，那在offset0x0的位置那裡的是什麼？可以確定不是虛基類的偏移，因為虛基類的偏移為0x10，那就應該是虛表指針了，那offset會在裡面嗎？
可以看到在vptr[-3]處有一個0x10的值，那虛基類的偏移量會是在vptr[-3]處嗎？，我們看一下反彙編是如何對指針進行操作的。
可以看到彙編代碼也正是這樣做的，相當於：pp2d = (pp3d == nulltr ? nullptr : pp3d + vptr[-3])。其中vptr為位於Point3D開頭，保存虛基類的虛表指針，而不是虛基類Point2D的虛表指針.
也就是說虛基類的偏移量不會保存在對象的記憶體佈局中，而是放在虛表中，而派生類不會復用虛基類的虛表指針（也應該這樣，虛基類都找不到怎麼用它的虛表指針找偏移量）。而且派生類的虛表指針和新成員變數是放在類的開頭的，並不是像沒有虛繼承那樣基類對象在最開頭（offset0x0的位置）。
其實在《深度探索C++對象模型》中說的是虛基類的偏移放到了vptr[-1]的位置，但我們知道在g++的實現里這個位置給了該類對應的typeinfo對象，g++實際上將虛基類偏移量放在了vptr[-3]。
派生類的非虛基類里都有虛表指針
那麼如果派生類還繼承（非虛繼承）了其他有虛函數表指針的類，那麼派生類會不會復用其虛表指針呢？類Vertex正是這樣，Point2D是它的虛基類，而VertexInterface是它的普通基類。類Point2D的size為16，VertexInterface的size為8（只包含一個虛表指針）。Vertex還有自己的成員變數m_next，size為8，這樣就湊夠32個位元組了，說明Vertex沒有生成自己的虛表指針，會復用非虛基類的虛表指針。
從調試結果來看，g++會在派生類的最前面按照生命順序放置非虛基類對象，然後放置派生類自己的成員，最後放置虛基類對象。
派生類繼承了擁有公共虛基類的兩個類
我們來算一下Vertex3D類裡面的各個成員及其size，首先Point3D除了虛基類Point2D外還有16位元組（虛表指針8，int成員4，對齊4），Vertex除了虛基類Point2D外還有16位元組（VertexInterface的虛表指針8，Vertex*成員8），Vertex3D自己的int成員4位元組，最後虛基類Point2D的size為16，對齊為8，所以前面要填充4位元組一共16+16+4+4+16=56位元組。正好是Vertex3D類的大小，所以繼承有公共虛基類的兩個類不會增加虛表指針，而是直接復用基類的虛表指針，用gdb查看可以看到其記憶體佈局正如上面所言。
所以，對於派生了繼承了有公共虛基類的兩個類，g++會將非虛基類的所有成員按聲明順序在記憶體中排列，再將派生類自己的成員放在記憶體里，最後就是虛基類。
最後，在使用分析類對象的時候，可以使用 p /x {objName}來查看對象內容和各個成員的值，我在寫這篇博客的時候就忘記對Vertex3D::m_mumble成員初始化，結果其是一個未初始化的值，而且我還我忘記了Vertex3D內還有這個成員，一直沒發現這個是什麼值，不知道為什麼出現了這未知的8位元組，使用p /x v3d命令後才發現是Vertex3D::m_mumble，浪費了很多時間。自己還有很多要提升的地方，gdb的這個用法來自《C++ 虛函數之一：對象記憶體佈局》。最後給大家展示一下p /x v3d後的結果：
(gdb) p /x v3d
$2 = {<Point3D> = {<Point2D> = {_vptr.Point2D = 0x8201b70 <vtable for Vertex3D+96>, m_x = 0x1, m_y = 0x2}, _vptr.Point3D = 0x8201b28 <vtable for Vertex3D+24>,
m_z = 0x3}, <Vertex> = {<VertexInterface> = {_vptr.VertexInterface = 0x8201b50 <vtable for Vertex3D+64>}, m_next = 0x0}, m_mumble = 0x4}
《深度探索C++對象模型》里還有對於成員指針的講解，但這篇博文已經很長了，就放在下一篇總結吧。
