看懂Qt源代碼-Qt源碼的對象數(shù)據(jù)存儲

第一次看Qt源代碼的人都會被其代碼所迷惑，經常會看到代碼中的d_ptr成員、d_func(函數(shù))和Q_DECLARE_PRIVATE等奇怪的宏，總是讓人一頭霧水，下面這篇文章很好的向我們介紹了Qt源代碼的編寫習慣，為我們看Qt源碼打下基礎：

對象數(shù)據(jù)存儲

前言，為什么先說這個？

???? 我們知道，在C++中，幾乎每一個類(class)中都需要有一些類的成員變量(class member variable)，在通常情況下的做法如下：

class?Person
{
private:
????string?mszName;?//?姓名
????bool?mbSex;????//?性別
????int?mnAge;?????//?年齡
};

? ? ?就是在類定義的時候，直接把類成員變量定義在這里，甚至于，把這些成員變量的存取范圍直接定義成是 public 的，您是不是這是這樣做的呢？

在Qt中，卻幾乎都不是這樣做的，那么，Qt是怎么做的呢？

???? 幾乎每一個C++的類中都會保存許多的數(shù)據(jù)，要想讀懂別人寫的C++代碼，就一定需要知道每一個類的的數(shù)據(jù)是如何存儲的，是什么含義，否則，我們不可能讀懂別人的C++代碼。在這里也就是說，要想讀懂Qt的代碼，第一步就必須先搞清楚Qt的類成員數(shù)據(jù)是如何保存的。

??? 為了更容易理解Qt是如何定義類成員變量的，我們先說一下Qt 2.x 版本中的類成員變量定義方法，因為在 2.x 中的方法非常容易理解。然后在介紹 Qt 4.6 中的類成員變量定義方法。

Qt 2.x 中的方法

在定義class的時候(在.h文件中)，只包含有一個類成員變量，只是定義一個成員數(shù)據(jù)指針，然后由這個指針指向一個數(shù)據(jù)成員對象，這個數(shù)據(jù)成員對象包含所有這個class的成員數(shù)據(jù)，然后在class的實現(xiàn)文件(.cpp文件)中，定義這個私有數(shù)據(jù)成員對象。示例代碼如下：

//————————————————————————————————————–
//?File?name:??person.h

struct?PersonalDataPrivate;?//?聲明私有數(shù)據(jù)成員類型

class?Person
{
public:

????Person?();???//?constructor
????virtual?~Person?();??//?destructor
????void?setAge(const?int);
????int?getAge();

private:

????PersonalDataPrivate*?d;
};

?

//————————————————————————————————————–
//?File?name:??person.cpp

struct?PersonalDataPrivate??//?定義私有數(shù)據(jù)成員類型
{
????string?mszName;?//?姓名
????bool?mbSex;????//?性別
????int?mnAge;?????//?年齡
};

//?constructor
Person::Person?()
{
????d?=?new?PersonalDataPrivate;
};

//?destructor
Person::~Person?()
{
????delete?d;
};

void?Person::setAge(const?int?age)
{
????if?(age?!=?d->mnAge)
????????d->mnAge?=?age;
}

int?Person::getAge()
{
????return?d->mnAge;
}

在最初學習Qt的時候，我也覺得這種方法很麻煩，但是隨著使用的增多，我開始很喜歡這個方法了，而且，現(xiàn)在我寫的代碼，基本上都會用這種方法。具體說來，它有如下優(yōu)點：

????* 減少頭文件的依賴性
????? 把具體的數(shù)據(jù)成員都放到cpp文件中去，這樣，在需要修改數(shù)據(jù)成員的時候，只需要改cpp文件而不需要頭文件，這樣就可以避免一次因為頭文件的修改而導致所有包含了這個文件的文件全部重新編譯一次，尤其是當這個頭文件是非常底層的頭文件和項目非常龐大的時候，優(yōu)勢明顯。
????? 同時，也減少了這個頭文件對其它頭文件的依賴性。可以把只在數(shù)據(jù)成員中需要用到的在cpp文件中include一次就可以，在頭文件中就可以盡可能的減少include語句
????* 增強類的封裝性
????? 這種方法增強了類的封裝性，無法再直接存取類成員變量，而必須寫相應的 get/set 成員函數(shù)來做這些事情。
????? 關于這個問題，仁者見仁，智者見智，每個人都有不同的觀點。有些人就是喜歡把類成員變量都定義成public的，在使用的時候方便。只是我個人不喜歡這種方法，當項目變得很大的時候，有非常多的人一起在做這個項目的時候，自己所寫的代碼處于底層有非常多的人需要使用(#include)的時候，這個方法的弊端就充分的體現(xiàn)出來了。

還有，我不喜歡 Qt 2.x 中把數(shù)據(jù)成員的變量名都定義成只有一個字母，d，看起來很不直觀，尤其是在search的時候，很不方便。但是，Qt kernel 中的確就是這么干的。

Qt 4.6.x 中的方法

在 Qt 4.6 中，類成員變量定義方法的出發(fā)點沒有變化，只是在具體的實現(xiàn)手段上發(fā)生了非常大的變化，下面具體來看。

在 Qt 4.6 中，使用了非常多的宏來做事，這憑空的增加了理解 Qt source code 的難度，不知道他們是不是從MFC學來的。就連在定義類成員數(shù)據(jù)變量這件事情上，也大量的使用了宏。

在這個版本中，類成員變量不再是給每一個class都定義一個私有的成員，而是把這一項common的工作放到了最基礎的基類 QObject 中，然后定義了一些相關的方法來存取，好了，讓我們進入具體的代碼吧。

//————————————————————————————————————–
//?file?name:?qobject.h

class?QObjectData
{
public:
????virtual?~QObjectData()?=?0;
????//?省略
};

class?QObject
{
????Q_DECLARE_PRIVATE(QObject)

public:

????QObject(QObject?*parent=0);

protected:

????QObject(QObjectPrivate?&dd,?QObject?*parent?=?0);
????QObjectData?*d_ptr;
}

這些代碼就是在 qobject.h 這個頭文件中的。在 QObject class 的定義中，我們看到，數(shù)據(jù)員的定義為：QObjectData *d_ptr; 定義成 protected 類型的就是要讓所有的派生類都可以存取這個變量，而在外部卻不可以直接存取這個變量。而 QObjectData 的定義卻放在了這個頭文件中，其目的就是為了要所有從QObject繼承出來的類的成員變量也都相應的要在QObjectData這個class繼承出來。而純虛的析構函數(shù)又決定了兩件事：

??? * 這個class不能直接被實例化。換句話說就是，如果你寫了這么一行代碼，new QObjectData， 這行代碼一定會出錯，compile的時候是無法過關的。
??? * 當 delete 這個指針變量的時候，這個指針變量是指向的任意從QObjectData繼承出來的對象的時候，這個對象都能被正確delete，而不會產生錯誤，諸如，內存泄漏之類的。

我們再來看看這個宏做了什么，Q_DECLARE_PRIVATE(QObject)

#define?Q_DECLARE_PRIVATE(Class)?
????inline?Class##Private*?d_func()?{?return?reinterpret_cast(d_ptr);?}?
????inline?const?Class##Private*?d_func()?const?{?return?reinterpret_cast(d_ptr);?}?
????friend?class?Class##Private;

這個宏主要是定義了兩個重載的函數(shù)，d_func()，作用就是把在QObject這個class中定義的數(shù)據(jù)成員變量d_ptr安全的轉換成為每一個具體的class的數(shù)據(jù)成員類型指針。我們看一下在QObject這個class中，這個宏展開之后的情況，就一幕了然了。

Q_DECLARE_PRIVATE(QObject) 展開后，就是下面的代碼：

inline?QObjectPrivate*?d_func()?{?return?reinterpret_cast(d_ptr);?}
inline?const?QObjectPrivate*?d_func()?const
{?return?reinterpret_cast(d_ptr);?}?
friend?class?QObjectPrivate;

宏展開之后，新的問題又來了，這個QObjectPrivate是從哪里來的？在QObject這個class中，為什么不直接使用QObjectData來數(shù)據(jù)成員變量的類型？

還記得我們剛才說過嗎，QObjectData這個class的析構函數(shù)的純虛函數(shù)，這就說明這個class是不能實例化的，所以，QObject這個class的成員變量的實際類型，這是從QObjectData繼承出來的，它就是QObjectPrivate !

這個 class 中保存了許多非常重要而且有趣的東西，其中包括 Qt 最核心的 signal 和 slot 的數(shù)據(jù)，屬性數(shù)據(jù)，等等，我們將會在后面詳細講解，現(xiàn)在我們來看一下它的定義：

下面就是這個class的定義：

class?QObjectPrivate?:?public?QObjectData
{
????Q_DECLARE_PUBLIC(QObject)

public:

????QObjectPrivate(int?version?=?QObjectPrivateVersion);
????virtual?~QObjectPrivate();
????//?省略
}

那么，這個 QObjectPrivate 和 QObject 是什么關系呢？他們是如何關聯(lián)在一起的呢？

讓我們來看看這個 QObjectPrivate 和 QObject 是如何關聯(lián)在一起的。

//————————————————————————————————————–
//?file?name:?qobject.cpp

QObject::QObject(QObject?*parent)?
????:?d_ptr(new?QObjectPrivate)
{
??//?………………………
}

QObject::QObject(QObjectPrivate?&dd,?QObject?*parent)
????:?d_ptr(&dd)
{
???//?…………………
}

怎么樣，是不是一目了然呀？

從第一個構造函數(shù)可以很清楚的看出來，QObject class 中的 d_ptr 指針將指向一個 QObjectPrivate 的對象，而QObjectPrivate這個class是從QObjectData繼承出來的。

這第二個構造函數(shù)干什么用的呢？從 QObject class 的定義中，我們可以看到，這第二個構造函數(shù)是被定義為 protected 類型的，這說明，這個構造函數(shù)只能被繼承的class使用，而不能使用這個構造函數(shù)來直接構造一個QObject對象，也就是說，如果寫一條下面的語句，編譯的時候是會失敗的，
??????? new QObject(*new QObjectPrivate, NULL)

為了看的更清楚，我們以QWidget這個class為例說明。

QWidget是QT中所有UI控件的基類，它直接從QObject繼承而來，

class?QWidget?:?public?QObject,?public?QPaintDevice
{
????Q_OBJECT
????Q_DECLARE_PRIVATE(QWidget)
????//?…………………
}

我們看一個這個class的構造函數(shù)的代碼：

QWidget::QWidget(QWidget?*parent,?Qt::WindowFlags?f)
????:?QObject(*new?QWidgetPrivate,?0),?QPaintDevice()
{
????d_func()->init(parent,?f);
}

非常清楚，它調用了基類QObject的保護類型的構造函數(shù)，并且以 *new QWidgetPrivate 作為第一個參數(shù)傳遞進去。也就是說，基類(QObject)中的d_ptr指針將會指向一個QWidgetPrivate類型的對象。

再看QWidgetPrivate這個class的定義：

class?QWidgetPrivate?:?public?QObjectPrivate
{
????Q_DECLARE_PUBLIC(QWidget)
????//?…………………
}

好了，這就把所有的事情都串聯(lián)起來了。

關于QWidget構造函數(shù)中的唯一的語句 d_func()->init(parent, f) 我們注意到在class的定義中有這么一句話： Q_DECLARE_PRIVATE(QWidget)

我們前面講過這個宏，當把這個宏展開之后，就是這樣的：

inline?QWidgetPrivate*?d_func()?{?return?reinterpret_cast(d_ptr);?}
inline?const?QWidgetPrivate*?d_func()?const
{?return?reinterpret_cast(d_ptr);?}?
friend?class?QWidgetPrivate;

很清楚，它就是把QObject中定義的d_ptr指針轉換為QWidgetPrivate類型的指針。

小結：

要理解Qt Kernel的code，就必須要知道Qt中每一個Object內部的數(shù)據(jù)是如何保存的，而Qt沒有象我們平時寫code一樣，把所有的變量直接定義在類中，所以，不搞清楚這個問題，我們就無法理解一個相應的class。其實，在Qt4.6中的類成員數(shù)據(jù)的保存方法在本質是與Qt2.x中的是一樣的，就是在class中定義一個成員數(shù)據(jù)的指針，指向成員數(shù)據(jù)集合對象(這里是一個QObjectData或者是其派生類)。初始化這個成員變量的辦法是定義一個保護類型的構造函數(shù)，然后在派生類的構造函數(shù)new 一個派生類的數(shù)據(jù)成員，并將這個新對象賦值給QObject的數(shù)據(jù)指針。在使用的時候，通過預先定義個宏里面的一個inline函數(shù)來把數(shù)據(jù)指針在安全類型轉換，就可以使用了。