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

Posted findumars

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Qt中容器类应该如何存储对象相关的知识,希望对你有一定的参考价值。

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

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

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

0.测试前的一点点准备

技术图片
 1 // testobj.h
 2 #ifndef TESTOBJ_H
 3 #define TESTOBJ_H
 4 
 5 #include <QObject>
 6 
 7 // 测试对象(也可以不继承QObject)
 8 class TestObj : public QObject
 9 {
10     Q_OBJECT
11 public:
12     explicit TestObj(QObject *parent = 0);
13 
14     ~TestObj();
15 
16     TestObj(const TestObj& obj);
17 
18     TestObj& operator=(const TestObj& obj);
19 
20 };
21 
22 #endif // TESTOBJ_H
技术图片

实现TestObj

技术图片
 1 // testobj.cpp
 2 #include "testobj.h"
 3 #include <QDebug>
 4 
 5 // 构造时输出log
 6 TestObj::TestObj(QObject *parent) : QObject(parent)
 7 {
 8     qDebug()<<"TestObj C.tor.";
 9 }
10 
11 // 析构时输出log
12 TestObj::~TestObj(){
13     qDebug()<<"TestObj D.tor.";
14 }
15 
16 // 拷贝时输出log
17 TestObj::TestObj(const TestObj& obj){
18 
19     qDebug()<<"TestObj COPY.";
20 }
21 
22 // 赋值时输出log
23 TestObj& TestObj::operator=(const TestObj& obj){
24 
25     qDebug()<<"TestObj =.";
26     return *this;
27 }
技术图片

 

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

技术图片
 1 // main.cpp
 2 #include <QCoreApplication>
 3 #include <QList>
 4 
 5 #include "testobj.h"
 6 
 7 int main(int argc, char *argv[])
 8 {
 9     QCoreApplication a(argc, argv);
10     
11     {
12         // Test one
13         {
14             TestObj obj;
15             {
16                 QList<TestObj> objList;
17                 objList.append(obj);
18             }
19 
20             qDebug()<<"ONE: "<<"objList release.";
21         }
22 
23         qDebug()<<"ONE: "<<"TestObj release.";
24         qDebug()<<endl;
25     }
26     
27     return a.exec();
28 }
技术图片

运行结果:

技术图片

结论:

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

 

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

技术图片
 1 // main.cpp
 2 #include <QCoreApplication>
 3 #include <QList>
 4 
 5 #include "testobj.h"
 6 
 7 int main(int argc, char *argv[])
 8 {
 9     QCoreApplication a(argc, argv);
10     
11     {
12         // test tow
13         {
14             TestObj *obj = new TestObj;
15             {
16                 QList<TestObj*> objList;
17                 objList.append(obj);
18             }
19             qDebug()<<"TWO: "<<"objList release.";
20         }
21 
22         qDebug()<<"TWO: "<<"TestObj release? NO!";
23         qDebug()<<endl;
24     }
25     
26     return a.exec();
27 }
技术图片

运行结果:

技术图片

结论:

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

 

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

技术图片
 1 // main.cpp
 2 #include <QCoreApplication>
 3 #include <QList>
 4 #include <QSharedPointer>
 5 
 6 #include "testobj.h"
 7 
 8 int main(int argc, char *argv[])
 9 {
10     QCoreApplication a(argc, argv);
11     
12     {
13         // test three
14         {
15             QSharedPointer<TestObj> obj(new TestObj);
16             {
17                 QList<QSharedPointer<TestObj>> objList;
18                 objList.append(obj);
19             }
20             qDebug()<<"THREE: "<<"objList release.";
21         }
22 
23         qDebug()<<"THREE: "<<"TestObj release? YES!";
24         qDebug()<<endl;
25     }
26     
27     return a.exec();
28 }
技术图片

运行结果:

技术图片

结论:

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

 

4.给测试对象一个parent(父对象),然后进行上述测试

技术图片
 1 // main.cpp
 2 #include <QCoreApplication>
 3 #include <QList>
 4 
 5 #include "testobj.h"
 6 
 7 int main(int argc, char *argv[])
 8 {
 9     QCoreApplication a(argc, argv);
10     
11     {
12         // test four
13         {
14             QObject root;
15             TestObj *obj = new TestObj(&root);
16             {
17                 QList<TestObj*> objList;
18                 objList.append(obj);
19             }
20             qDebug()<<"FOUR: "<<"objList release.";
21         }
22 
23         qDebug()<<"FOUR: "<<"TestObj release? YES!";
24         qDebug()<<endl;
25     }
26     
27     return a.exec();
28 }
技术图片

 运行结果:

技术图片

结论: 

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

 

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

技术图片
 1 // main.cpp
 2 #include <QCoreApplication>
 3 #include <QList>
 4 #include <QSharedPointer>
 5 
 6 #include "testobj.h"
 7 
 8 int main(int argc, char *argv[])
 9 {
10     QCoreApplication a(argc, argv);
11     
12     {
13         // test five
14         {
15             {
16                 QList<TestObj*> objList;
17                 TestObj *obj = new TestObj(&objList); // Error: QList<> is NOT a QObject.
18                 objList.append(obj);
19             }
20             qDebug()<<"FIVE: "<<"objList release.";
21             qDebug()<<"FIVE: "<<"TestObj release? ERROR!";
22         }
23 
24         qDebug()<<endl;
25     }
26     
27     return a.exec();
28 }
技术图片

测试结果:

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

结论:

// qlist.h

技术图片

// qbytearraylist.h

技术图片

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

 

6.扩展一下 QList,继承QObject

技术图片
 1 // testobjlist.h
 2 #ifndef TESTOBJLIST_H
 3 #define TESTOBJLIST_H
 4 
 5 #include <QObject>
 6 #include <QList>
 7 
 8 class TestObj;
 9 
10 class TestObjList : public QObject, public QList<TestObj*>
11 {
12     Q_OBJECT
13 public:
14     explicit TestObjList(QObject *parent = 0);
15     ~TestObjList();
16 };
17 
18 #endif // TESTOBJLIST_H
技术图片
技术图片
 1 // testobjlist.cpp
 2 #include "testobjlist.h"
 3 #include "testobj.h"
 4 #include <QDebug>
 5 
 6 TestObjList::TestObjList(QObject *parent) : QObject(parent)
 7 {
 8     qDebug()<<"TestObjList C.tor.";
 9 }
10 
11 TestObjList::~TestObjList()
12 {
13     qDebug()<<"TestObjList D.tor.";
14 }
技术图片

测试:

技术图片
 1 // main.cpp
 2 #include <QCoreApplication>
 3 #include <QList>
 4 #include <QSharedPointer>
 5 
 6 #include "testobj.h"
 7 #include "testobjlist.h"
 8 
 9 int main(int argc, char *argv[])
10 {
11     QCoreApplication a(argc, argv);
12     
13     {
14         // test six
15         {
16             {
17                 TestObjList objList;
18                 TestObj *obj = new TestObj(&objList); // Error: QList<> is NOT a QObject.
19                 objList.append(obj);
20             }
21             qDebug()<<"SIX: "<<"objList release.";
22             qDebug()<<"SIX: "<<"TestObj release? YES!";
23         }
24 
25         qDebug()<<endl;
26     }
27     
28     return a.exec();
29 }
技术图片

测试结果:

技术图片

结论:

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

 

7.附加测试

1 {
2         TestObjList objList;
3         TestObjList list2 = objList; // Error: QObject Q_DISABLE_COPY
4 }

结论:

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

 

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

https://www.cnblogs.com/pyw0818/p/8039233.html

以上是关于Qt中容器类应该如何存储对象的主要内容,如果未能解决你的问题,请参考以下文章

QT内省机制自定义Model数据库

如何将此信息存储在qt中?数组列表?

带有对象的 Qt 容器

sql 这些代码片段将演示如何逐步使用PolyBase。你应该有一个blob存储和存储秘密方便

在 "容器 "类属性对象中添加多个类实例。

Qt容器类的对象模型及应用(线性结构篇)(好多图,比较清楚)