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 = 0);

    ~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 = 0);
    ~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 的方法来管理内存，避免内存泄露。