Qt中容器类应该如何存储对象

Qt提供了丰富的容器类型，如：QList、QVector、QMap等等。详细的使用方法可以参考官方文档，网上也有很多示例文章，不过大部分文章的举例都是使用基础类型：如int、QString等。如果我们要存储一个对象类型，应该如何做呢？—— 当然是和int类型一样操作，因为这些容器类都是泛型的。不过，我们今天要讨论的不是容器类的使用用法，而是容器存储的对象内存如何释放的问题。

（这里提到了对象类型是指 Class/Struct，可以继承自QObject，也可以是普通的C++类。）

下面以QList<T>为例，直接通过代码来看一下以下几种情况的内存释放。

0.测试前的一点点准备

 // testobj.h
 #ifndef TESTOBJ_H
 #define TESTOBJ_H

 #include <QObject>

 // 测试对象（也可以不继承QObject）
 class TestObj : public QObject
 {
     Q_OBJECT
 public:
     explicit TestObj(QObject *parent = );

     ~TestObj();

     TestObj(const TestObj& obj);

     TestObj& operator=(const TestObj& obj);

 };

 #endif // TESTOBJ_H

实现TestObj

 // testobj.cpp
 #include "testobj.h"
 #include <QDebug>

 // 构造时输出log
 TestObj::TestObj(QObject *parent) : QObject(parent)
 {
     qDebug()<<"TestObj C.tor.";
 }

 // 析构时输出log
 TestObj::~TestObj(){
     qDebug()<<"TestObj D.tor.";
 }

 // 拷贝时输出log
 TestObj::TestObj(const TestObj& obj){

     qDebug()<<"TestObj COPY.";
 }

 // 赋值时输出log
 TestObj& TestObj::operator=(const TestObj& obj){

     qDebug()<<"TestObj =.";
     return *this;
 }

1.在栈上创建对象，然后添加容器

 // main.cpp
 #include <QCoreApplication>
 #include <QList>

 #include "testobj.h"

 int main(int argc, char *argv[])
 {
     QCoreApplication a(argc, argv);

     {
         // Test one
         {
             TestObj obj;
             {
                 QList<TestObj> objList;
                 objList.append(obj);
             }

             qDebug()<<"ONE: "<<"objList release.";
         }

         qDebug()<<"ONE: "<<"TestObj release.";
         qDebug()<<endl;
     }

     return a.exec();
 }

运行结果：

结论：

对象加入到容器时会发生拷贝，容器析构时，容器内的对象也会析构。

2. 在堆上创建对象，然后添加到容器 

 // main.cpp
 #include <QCoreApplication>
 #include <QList>

 #include "testobj.h"

 int main(int argc, char *argv[])
 {
     QCoreApplication a(argc, argv);

     {
         // test tow
         {
             TestObj *obj = new TestObj;
             {
                 QList<TestObj*> objList;
                 objList.append(obj);
             }
             qDebug()<<"TWO: "<<"objList release.";
         }

         qDebug()<<"TWO: "<<"TestObj release? NO!";
         qDebug()<<endl;
     }

     return a.exec();
 }

运行结果：

结论：

对象不会发生拷贝，但容器析构后容器内的对象并未析构

3. 使用Qt智能指针来管理堆上的对象，然后添加到容器

 // main.cpp
 #include <QCoreApplication>
 #include <QList>
 #include <QSharedPointer>

 #include "testobj.h"

 int main(int argc, char *argv[])
 {
     QCoreApplication a(argc, argv);

     {
         // test three
         {
             QSharedPointer<TestObj> obj(new TestObj);
             {
                 QList<QSharedPointer<TestObj>> objList;
                 objList.append(obj);
             }
             qDebug()<<"THREE: "<<"objList release.";
         }

         qDebug()<<"THREE: "<<"TestObj release? YES!";
         qDebug()<<endl;
     }

     return a.exec();
 }

运行结果：

结论：

对象不会发生拷贝，容器析构的时候，容器内对象并未析构，但超过作用域后，智能指针管理的对象会析构。

4.给测试对象一个parent（父对象），然后进行上述测试

 // main.cpp
 #include <QCoreApplication>
 #include <QList>

 #include "testobj.h"

 int main(int argc, char *argv[])
 {
     QCoreApplication a(argc, argv);

     {
         // test four
         {
             QObject root;
             TestObj *obj = new TestObj(&root);
             {
                 QList<TestObj*> objList;
                 objList.append(obj);
             }
             qDebug()<<"FOUR: "<<"objList release.";
         }

         qDebug()<<"FOUR: "<<"TestObj release? YES!";
         qDebug()<<endl;
     }

     return a.exec();
 }

运行结果：

结论：

这里的root对象起到了类似智能指针的作用，这也是Qt的一个特性，即在父对象析构的时候，会将其左右子对象析构。（注意：普通C++对象并无此特性））

5.将QList作为测试对象的parent，然后进行上述测试

 // main.cpp
 #include <QCoreApplication>
 #include <QList>
 #include <QSharedPointer>

 #include "testobj.h"

 int main(int argc, char *argv[])
 {
     QCoreApplication a(argc, argv);

     {
         // test five
         {
             {
                 QList<TestObj*> objList;
                 TestObj *obj = new TestObj(&objList); // Error: QList<> is NOT a QObject.
                 objList.append(obj);
             }
             qDebug()<<"FIVE: "<<"objList release.";
             qDebug()<<"FIVE: "<<"TestObj release? ERROR!";
         }

         qDebug()<<endl;
     }

     return a.exec();
 }

测试结果：

 // 编译错误，因为QList并不继承自QObject，所以不能作为TestObj的parent

结论：

// qlist.h

// qbytearraylist.h

QList并不是QObject，只是普通的模板类

6.扩展一下 QList，继承QObject

 // testobjlist.h
 #ifndef TESTOBJLIST_H
 #define TESTOBJLIST_H

 #include <QObject>
 #include <QList>

 class TestObj;

 class TestObjList : public QObject, public QList<TestObj*>
 {
     Q_OBJECT
 public:
     explicit TestObjList(QObject *parent = );
     ~TestObjList();
 };

 #endif // TESTOBJLIST_H

 // testobjlist.cpp
 #include "testobjlist.h"
 #include "testobj.h"
 #include <QDebug>

 TestObjList::TestObjList(QObject *parent) : QObject(parent)
 {
     qDebug()<<"TestObjList C.tor.";
 }

 TestObjList::~TestObjList()
 {
     qDebug()<<"TestObjList D.tor.";
 }

测试：

 // main.cpp
 #include <QCoreApplication>
 #include <QList>
 #include <QSharedPointer>

 #include "testobj.h"
 #include "testobjlist.h"

 int main(int argc, char *argv[])
 {
     QCoreApplication a(argc, argv);

     {
         // test six
         {
             {
                 TestObjList objList;
                 TestObj *obj = new TestObj(&objList); // Error: QList<> is NOT a QObject.
                 objList.append(obj);
             }
             qDebug()<<"SIX: "<<"objList release.";
             qDebug()<<"SIX: "<<"TestObj release? YES!";
         }

         qDebug()<<endl;
     }

     return a.exec();
 }

测试结果：

结论：

TestObjList 释放的时候会释放其内部的对象

7.附加测试

 {
         TestObjList objList;
         TestObjList list2 = objList; // Error: QObject Q_DISABLE_COPY
 }

结论：

Qt为了防止开发者出错，将QObject的类拷贝构造函数和赋值操作符都DISABLE了。这样做的好处是，一旦开发者不小心定义了一个QList<QObject>的容器，在添加对象时就会得到一个编译错误，从而避免发生隐式拷贝。

总结，使用容器类存储对象时，最好使用对象指针类型，如：QList<TestObj*>，而不要使用 QList<TestObj> 这样的定义。建议采用 智能指针QSharedPointer 或 为对象设置parent 的方法来管理内存，避免内存泄露。