Qt父子对象内存管理实现简析

用Qt大家都知道Qt有一套自己的内存管理机制：父子对象管理机制。适用于所有继承于QObject的类。即在一个类中指定他的父对象，可以用void QObject::setParent(QObject * parent)函数指定，也可以在构造时传入参数，一般继承自QObject的类，Qt-c自动生成的类模板的构造函数都是explicit 类名(QObject *parent = 0);这个parent就是你可以制定的父对象。当一个对象删除之后，会自动删除他的所有的子对象，这样你就可以有很多new，但是只有一个delete。（注：这个父子对象关系和继承的父子类是不一样的，而且可以说基本没关系的。）

下面我们就扒下Qt的源码，找下它的实现。

主要就是集中在QObject类的实现。其中出现的地方就是构造函数，析构函数，setParent函数和QObjectPrivate类的setParent_helper和deleteChildren函数。

其中QObject和QObjectPrivate的关系，也是Qt中d-pointer的应用，关于d-pointer的内容，见链接：http://qt-project.org/wiki/Dpointer_SimplifiedChinese 和 http://www.cnblogs.com/SkylineSoft/articles/2046391.html

首先先说一个类成员结构，来保存标志位和子对象列表，和父对象指针。

class Q_CORE_EXPORT QObjectData {
public:
   virtual ~QObjectData() = 0;
   QObject *q_ptr;
   QObject *parent;
   QObjectList children;

   uint isWidget : 1;
   uint blockSig : 1;
   uint wasDeleted : 1;
   uint isDeletingChildren : 1;
   uint sendChildEvents : 1;
   uint receiveChildEvents : 1;
   uint isWindow : 1; //for QWindow
   uint unused : 25;
   int postedEvents;
   QDynamicMetaObjectData *metaObject;
   QMetaObject *dynamicMetaObject() const;
};

其中：

QObjectPrivate继承自QObjectData。

QObjectList 是：typedef QList<QObject*> QObjectList;

类似：uint  wasDeleted : 1; 这个冒号(:)的作用是指定这个unsigned  int内存对齐方式。

接着我们先看写QObject构造函数中的相关代码：

if (parent) {
       QT_TRY {
           if (!check_parent_thread(parent, parent ? parent->d_func()->threadData : 0, d->threadData))
               parent = 0;
           setParent(parent);
       } QT_CATCH(...) {
           d->threadData->deref();
           QT_RETHROW;
       }
   }

其中涉及到几个宏先说明下：

#  define QT_TRY try

#  define QT_CATCH(A) catch (A)

#  define QT_THROW(A) throw A

还有parent->d_func()是d-pointer的一个应用，返回的是QObjectPrivate * 。check_parent_thread函数是检查设置的父对象和当前对象是否是在一个线程，如果不是就返回false，这样就取消设置父对象，parent = 0;也就是把父对象设置为空。

parent ? parent->d_func()->threadData : 0  是一个三目运算，只有你设置了parent才会取出来他的线程信息，否则传进去是0,也就是空。

d->threadData ：这还是d-pointer，d也就是当前QObject对应的QObjectPrivate对象的指针。

check_parent_thread的实现很简单，

如下就是简单的判断而已：

static bool check_parent_thread(QObject *parent,
                               QThreadData *parentThreadData,
                               QThreadData *currentThreadData)
{
   if (parent && parentThreadData != currentThreadData) {
       QThread *parentThread = parentThreadData->thread;
       QThread *currentThread = currentThreadData->thread;
       qWarning("QObject: Cannot create children for a parent that is in a different thread.n"
                "(Parent is %s(%p), parent's thread is %s(%p), current thread is %s(%p)",
                parent->metaObject()->className(),
                parent,
                parentThread ? parentThread->metaObject()->className() : "QThread",
                parentThread,
                currentThread ? currentThread->metaObject()->className() : "QThread",
                currentThread);
       return false;
   }
   return true;
}

接着就是调用setParent函数了，我们就接着说setParent函数。

setParent函数的实现十分简单，只有三句话：

void QObject::setParent(QObject *parent)
{
   Q_D(QObject);
   Q_ASSERT(!d->isWidget);
   d->setParent_helper(parent);
}

Q_D(QObject); 这是d-pointer，利用Q_D宏声明和定义QObjectPrivate * d.

Q_ASSERT(!d->isWidget); 断言d不是QWidgetPrivate 或者 其子类，也就是当前类不是QWidget或者其子类，QWidget重写了setParent函数，只支持QWidget设置父子对象的。

d->setParent_helper(parent);调用QObjectPrivate的setParent_helper函数。

接着说QObjectPrivate的setParent_helper函数。

void QObjectPrivate::setParent_helper(QObject *o)
{
   Q_Q(QObject);
   if (o == parent)
       return;
   if (parent) {
       QObjectPrivate *parentD = parent->d_func();
       if (parentD->isDeletingChildren && wasDeleted
           && parentD->currentChildBeingDeleted == q) {
           // don't do anything since QObjectPrivate::deleteChildren() already
           // cleared our entry in parentD->children.
       } else {
           const int index = parentD->children.indexOf(q);
           if (parentD->isDeletingChildren) {
               parentD->children[index] = 0;
           } else {
               parentD->children.removeAt(index);
               if (sendChildEvents && parentD->receiveChildEvents) {
                   QChildEvent e(QEvent::ChildRemoved, q);
                   QCoreApplication::sendEvent(parent, &e);
               }
           }
       }
   }
   parent = o;
   if (parent) {
       // object hierarchies are constrained to a single thread
       if (threadData != parent->d_func()->threadData) {
           qWarning("QObject::setParent: Cannot set parent, new parent is in a different thread");
           parent = 0;
           return;
       }
       parent->d_func()->children.append(q);
       if(sendChildEvents && parent->d_func()->receiveChildEvents) {
           if (!isWidget) {
               QChildEvent e(QEvent::ChildAdded, q);
               QCoreApplication::sendEvent(parent, &e);
           }
       }
   }
   if (!wasDeleted && !isDeletingChildren && declarativeData && QAbstractDeclarativeData::parentChanged)
       QAbstractDeclarativeData::parentChanged(declarativeData, q, o);
}

Q_Q(QObject);开始是去出来QObject * q指针。

接着判断当前对象的夫对象和你要设置的父对象是否一样，一样的话直接返回。

如果设置的夫对象和当前不一致，而且设置的父对象有值，就在父对象中移除当前子对象。

if (parentD->isDeletingChildren && wasDeleted && parentD->currentChildBeingDeleted == q) ：这是判断是不是父对象在析构而且在删除当前对象而设置的。如果是则不做任何事情。parentD->isDeletingChildren和parentD->currentChildBeingDeleted是在QObjectPrivate::deleteChildren()设置的，wasDeleted这是系够函数~QObject设置的。

如果不是，还要判断，如果夫对象正在析构的话，也就直接设置副对象此子对象无效，否则就从父对象中删除此子对象。

接着把父对象设置为所要设置的对象。

然后为父对象添加此子对象，添加钱同样判断下父对象和子对象是否是在同一个线程，不再一个线程的话就取消设置，输出警告信息。

如果是在同一个线程，就为夫对象追加此子对象： parent->d_func()->children.append(q);

 

Next：我们就说下析构时的实现。

QObject::~QObject()
{
   Q_D(QObject);//设置d
   d->wasDeleted = true;
······
if (!d->children.isEmpty())
       d->deleteChildren();

   qt_removeObject(this);

   if (d->parent)        // remove it from parent object
       d->setParent_helper(0);
}

其中，中间很多是处理信号槽的逻辑，就直接省略了，找出我们主题相关的代码。

   d->wasDeleted = true; 设置是否是析构的标志位。

if (!d->children.isEmpty()) d->deleteChildren(); 如果有子对象的话就调用deleteChildren函数。

 d->setParent_helper(0);设置父对象为0。也就是从夫父对象中删除次子对象。

QObjectPrivate::deleteChildren函数：

void QObjectPrivate::deleteChildren()
{
   Q_ASSERT_X(!isDeletingChildren, "QObjectPrivate::deleteChildren()", "isDeletingChildren already set, did this function recurse?");
   isDeletingChildren = true;
   // delete children objects
   // don't use qDeleteAll as the destructor of the child might
   // delete siblings
   for (int i = 0; i < children.count(); ++i) {
       currentChildBeingDeleted = children.at(i);
       children[i] = 0;
       delete currentChildBeingDeleted;
   }
   children.clear();
   currentChildBeingDeleted = 0;
   isDeletingChildren = false;
}

第一句，先断言已经开始再删除对象了，不是在删除，才能执行。

设置标志位，开始循环删除，也就是调用每个子对象的析构函数。

currentChildBeingDeleted是一个内部成员变量。

 

到此，对于这个实现，你应该对这个实现很熟悉了吧？这个设计很好的，了解了，以后自己做项目也可以自己构建一个父子对象内存管理机制的。