Qt浅谈内存泄露(总结)

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Qt浅谈内存泄露(总结)相关的知识,希望对你有一定的参考价值。

Qt浅谈内存泄露(总结)

来源 http://blog.csdn.net/taiyang1987912/article/details/29271549

一、简介

       Qt内存管理机制:Qt 在内部能够维护对象的层次结构。对于可视元素,这种层次结构就是子组件与父组件的关系;对于非可视元素,则是一个对象与另一个对象的从属关系。在 Qt 中,在 Qt 中,删除父对象会将其子对象一起删除。

       C++中delete 和 new 必须配对使用(一 一对应):delete少了,则内存泄露,多了麻烦更大。Qt中使用了new却很少delete,因为QObject的类及其继承的类,设置了parent(也可在构造时使用setParent函数或parent的addChild)故parent被delete时,这个parent的相关所有child都会自动delete,不用用户手动处理。但parent是不区分它的child是new出来的还是在栈上分配的。这体现delete的强大,可以释放掉任何的对象,而delete栈上对象就会导致内存出错,这需要了解Qt的半自动的内存管理。另一个问题:child不知道它自己是否被delete掉了,故可能会出现野指针。那就要了解Qt的智能指针QPointer。

二、关联图

 

(1)Linux内存图,主要了解堆栈上分配内存的不同方式。

技术分享技术分享

(2)在Qt中,最基础和核心的类是:QObject,QObject内部有一个list,会保存children,还有一个指针保存parent,当自己析构时,会自己从parent列表中删除并且析构所有的children。

技术分享

 

三、详解

 

1、Qt的半自动化的内存管理

(1)QObject及其派生类的对象,如果其parent非0,那么其parent析构时会析构该对象。

(2)QWidget及其派生类的对象,可以设置 Qt::WA_DeleteOnClose 标志位(当close时会析构该对象)。

(3)QAbstractAnimation派生类的对象,可以设置 QAbstractAnimation::DeleteWhenStopped。

(4)QRunnable::setAutoDelete()、MediaSource::setAutoDelete()。

(5)父子关系:父对象、子对象、父子关系。这是Qt中所特有的,与类的继承关系无关,传递参数是与parent有关(基类、派生类,或父类、子类,这是对于派生体系来说的,与parent无关)。

 

2、内存问题例子

 

  • 例子一

 
  1. #include <QApplication>  
  2. #include <QLabel>  
  3.   
  4. int main(int argc, char *argv[])  
  5. {  
  6.     QApplication a(argc, argv);  
  7.     QLabel *label = new QLabel("Hello Qt!");  
  8.     label->show();  
  9.     return a.exec();  
  10. }  

分析:(1)label 既没有指定parent,也没有对其调用delete,所以会造成内存泄漏。书中的这种小例子也会出现指针内存的问题。
改进方式:(1)分配对象到栈上而不是堆上

  1. #include <QApplication>  
  2. #include <QLabel>  
  3.   
  4. int main(int argc, char *argv[])  
  5. {  
  6.     QApplication a(argc, argv);  
  7.     QLabel label("Hello Qt!");  
  8.     label.show();  
  9.     return a.exec();  
  10. }  

(2)设置标志位,close()后会delete label。

  1. label->setAttribute(Qt::WA_DeleteOnClose);  

(3)new后手动delete

  1. #include <QApplication>  
  2. #include <QLabel>  
  3.   
  4. int main(int argc, char *argv[])  
  5. {  
  6.     int ret = 0;  
  7.     QApplication a(argc, argv);  
  8.     QLabel *label = new QLabel("Hello Qt!");  
  9.     label->show();  
  10.     ret = a.exec();  
  11.     delete label;  
  12.     return ret;  
  13. }  
  • 例子二

  1. #include <QApplication>  
  2. #include <QLabel>  
  3. int main(int argc, char *argv[])  
  4. {  
  5.     QApplication app(argc, argv);  
  6.     QLabel label("Hello Qt!");  
  7.     label.show();  
  8.     label.setAttribute(Qt::WA_DeleteOnClose);  
  9.     return app.exec();  
  10. }  

运行:
技术分享
分析:程序崩溃,因为label被close时,delete &label;但label对象是在栈上分配的内存空间,delete栈上的地址会出错。

有些朋友理解为label被delete两次而错误,可以测试QLabel label("Hello Qt!"); label.show();delete &label;第一次delete就会出错。

  • 例子三

  1. #include <QApplication>  
  2. #include <QLabel>  
  3. int main(int argc, char* argv[])  
  4. {  
  5.    QApplication app(argc, argv);  
  6.    QLabel label("Hello Qt!");  
  7.    QWidget w;  
  8.    label.setParent(&w);  
  9.    w.show();  
  10.    return app.exec();  
  11. }  


分析:Object内部有一个list,会保存children,还有一个指针保存parent,当自己析构时,会自己从parent列表中删除并且析构所有的children。

w比label先被析构,当w被析构时,会删除chilren列表中的对象label,但label是分配到栈上的,因delete栈上的对象而出错。

改进方式:(1)调整一下顺序,确保label先于其parent被析构,label析构时将自己从父对象的列表中移除自己,w析构时,children列表中就不会有分配在stack中的对象了。

  1. #include <QApplication>  
  2. #include <QLabel>  
  3. int main(int argc, char* argv[])  
  4. {  
  5.    QApplication app(argc, argv);  
  6.    QWidget w;  
  7.    QLabel label("Hello Qt!");  
  8.    label.setParent(&w);  
  9.    w.show();  
  10.    return app.exec();  
  11. }  


(2)将label分配到堆上

QLabel *label = new QLabel("Hello Qt!");
label->setParent(&w)

或者QLabel *label = new QLabel("Hello Qt!",this);

  • 例子四:野指针

  1. #include <QApplication>  
  2. #include <QLabel>  
  3. int main(int argc, char* argv[])  
  4. {  
  5.    QApplication app(argc, argv);  
  6.    QWidget *w = new QWidget;  
  7.    QLabel *label = new QLabel("Hello Qt!");  
  8.    label->setParent(w);  
  9.    w->show();  
  10.    delete w;  
  11.    label->setText("go");     //野指针  
  12.    return app.exec();  
  13. }  

(上述程序不显示Label,仅作测试)

 

分析:程序异常结束,delete w时会delete label,label成为野指针,调用label->setText("go");出错。

改进方式:QPointer智能指针

  1. #include <QApplication>  
  2. #include <QLabel>  
  3. #include <QPointer>  
  4. int main(int argc, char* argv[])  
  5. {  
  6.    QApplication app(argc, argv);  
  7.    QWidget *w = new QWidget;  
  8.    QLabel *label = new QLabel("Hello Qt!");  
  9.    label->setParent(w);  
  10.    QPointer<QLabel> p = label;  
  11.    w->show();  
  12.    delete w;  
  13.    if (!p.isNull()) {  
  14.      label->setText("go");  
  15.    }  
  16.    return app.exec();  
  17. }  

 

  • 例子五:deleteLater

      当一个QObject正在接受事件队列时如果中途被你销毁掉了,就是出现问题了,所以QT中建大家不要直接Delete掉一个QObject,如果一定要这样做,要使用QObject的deleteLater()函数,它会让所有事件都发送完一切处理好后马上清除这片内存,而且就算调用多次的deletelater也不会有问题。

发送一个删除事件到事件系统:

 
  1. void QObject::deleteLater()  
  2. {  
  3.     QCoreApplication::postEvent(this, new QEvent(QEvent::DeferredDelete));  
  4. }  

 

3、智能指针

 

        如果没有智能指针,程序员必须保证new对象能在正确的时机delete,四处编写异常捕获代码以释放资源,而智能指针则可以在退出作用域时(不管是正常流程离开或是因异常离开)总调用delete来析构在堆上动态分配的对象。

Qt家族的智能指针:

 

智能指针

 

引入

QPointer

Qt Object 模型的特性(之一)
注意:析构时不会delete它管理的资源

 

QSharedPointer

带引用计数

Qt4.5

QWeakPointer

 

Qt4.5

QScopedPointer

 

Qt4.6

QScopedArrayPointer

QScopedPointer的派生类

Qt4.6

QSharedDataPointer

用来实现Qt的隐式共享(Implicit Sharing)

Qt4.0

QExplicitlySharedDataPointer

显式共享

Qt4.4

     

std::auto_ptr

   

std::shared_ptr

std::tr1::shared_ptr

C++0x

std::weak_ptr

std::tr1::weak_ptr

C++0x

std::unique_ptr

boost::scoped_ptr

C++0x

 

 

(1)QPointer

      QPointer是一个模板类。它很类似一个普通的指针,不同之处在于,QPointer 可以监视动态分配空间的对象,并且在对象被 delete 的时候及时更新。

     QPointer的现实原理:在QPointer保存了一个QObject的指针,并把这个指针的指针(双指针)交给全局变量管理,而QObject 在销毁时(析构函数,QWidget是通过自己的析构函数的,而不是依赖QObject的)会调用QObjectPrivate::clearGuards 函数来把全局 GuardHash 的那个双指针置为*零,因为是双指针的问题,所以QPointer中指针当然也为零了。用isNull 判断就为空了。

  1. // QPointer 表现类似普通指针   
  2. QDate *mydate = new QDate(QDate::currentDate());   
  3. QPointer mypointer = mydata;   
  4. mydate->year();    // -> 2005   
  5. mypointer->year(); // -> 2005   
  6.     
  7. // 当对象 delete 之后,QPointer 会有不同的表现   
  8. delete mydate;   
  9.     
  10. if(mydate == NULL)   
  11.     printf("clean pointer");   
  12. else   
  13.     printf("dangling pointer");   
  14. // 输出 dangling pointer   
  15.     
  16. if(mypointer.isNull())   
  17.     printf("clean pointer");   
  18. else   
  19.     printf("dangling pointer");   
  20. // 输出 clean pointer  

(2)std::auto_ptr

  1. // QPointer 表现类似普通指针   
  2. QDate *mydate = new QDate(QDate::currentDate());   
  3. QPointer mypointer = mydata;   
  4. mydate->year();    // -> 2005   
  5. mypointer->year(); // -> 2005   
  6.     
  7. // 当对象 delete 之后,QPointer 会有不同的表现   
  8. delete mydate;   
  9.     
  10. if(mydate == NULL)   
  11.     printf("clean pointer");   
  12. else   
  13.     printf("dangling pointer");   
  14. // 输出 dangling pointer   
  15.     
  16. if(mypointer.isNull())   
  17.     printf("clean pointer");   
  18. else   
  19.     printf("dangling pointer");   
  20. // 输出 clean pointe  

auto_ptr被销毁时会自动删除它指向的对象。

std::auto_ptr<QLabel> label(new QLabel("Hello Dbzhang800!"));

(3)其他的类参考相应文档。

 

4、自动垃圾回收机制

(1)QObjectCleanupHandler

 

      Qt 对象清理器是实现自动垃圾回收的很重要的一部分。QObjectCleanupHandler可以注册很多子对象,并在自己删除的时候自动删除所有子对象。同时,它也可以识别出是否有子对象被删 除,从而将其从它的子对象列表中删除。这个类可以用于不在同一层次中的类的清理操作,例如,当按钮按下时需要关闭很多窗口,由于窗口的 parent 属性不可能设置为别的窗口的 button,此时使用这个类就会相当方便。

 
  1. #include <QApplication>  
  2. #include <QObjectCleanupHandler>  
  3. #include <QPushButton>  
  4.   
  5. int main(int argc, char* argv[])  
  6. {  
  7.    QApplication app(argc, argv);  
  8.    // 创建实例  
  9.    QObjectCleanupHandler *cleaner = new QObjectCleanupHandler;  
  10.    // 创建窗口  
  11.    QPushButton *w = new QPushButton("Remove Me");  
  12.    w->show();  
  13.    // 注册第一个按钮  
  14.    cleaner->add(w);  
  15.    // 如果第一个按钮点击之后,删除自身  
  16.    QObject::connect(w, SIGNAL(clicked()), w, SLOT(deleteLater()));  
  17.    // 创建第二个按钮,注意,这个按钮没有任何动作  
  18.    w = new QPushButton("Nothing");  
  19.    cleaner->add(w);  
  20.    w->show();  
  21.    // 创建第三个按钮,删除所有  
  22.    w = new QPushButton("Remove All");  
  23.    cleaner->add(w);  
  24.    QObject::connect(w, SIGNAL(clicked()), cleaner, SLOT(deleteLater()));  
  25.    w->show();  
  26.    return app.exec();  
  27. }  

      技术分享 

 

      在上面的代码中,创建了三个仅有一个按钮的窗口。第一个按钮点击后,会删除掉自己(通过 deleteLater() 槽),此时,cleaner 会自动将其从自己的列表中清除。第三个按钮点击后会删除 cleaner,这样做会同时删除掉所有未关闭的窗口。

(2)引用计数
  应用计数是最简单的垃圾回收实现:每创建一个对象,计数器加 1,每删除一个则减 1。

 
  1. class CountedObject : public QObject   
  2. {   
  3.     Q_OBJECT   
  4. public:   
  5.     CountedObject()   
  6.     {   
  7.         ctr=0;   
  8.     }   
  9.     
  10.     void attach(QObject *obj)   
  11.     {   
  12.         ctr++;   
  13.         connect(obj, SIGNAL(destroyed(QObject*)), this, SLOT(detach()));   
  14.     }   
  15.     
  16. public slots:   
  17.     void detach()   
  18.     {   
  19.         ctr--;   
  20.         if(ctr <= 0)   
  21.             delete this;   
  22.     }   
  23.     
  24. private:   
  25.     int ctr;   
  26. };  

      利用Qt的信号槽机制,在对象销毁的时候自动减少计数器的值。但是,我们的实现并不能防止对象创建的时候调用了两次attach()。

 

(3)记录所有者

     更合适的实现是,不仅仅记住有几个对象持有引用,而且要记住是哪些对象。例如:

 
  1. class CountedObject : public QObject   
  2. {   
  3.    public:   
  4.       CountedObject() {}   
  5.        
  6.       void attach(QObject *obj) {   
  7.         // 检查所有者   
  8.         if(obj == 0)   
  9.           return;   
  10.         // 检查是否已经添加过   
  11.         if(owners.contains(obj))   
  12.           return;   
  13.         // 注册   
  14.         owners.append(obj);   
  15.         connect(obj, SIGNAL(destroyed(QObject*)), this, SLOT(detach(QObject*)));   
  16.       }    
  17.    public slots:   
  18.       void detach(QObject *obj) {   
  19.         // 删除   
  20.         owners.removeAll(obj);   
  21.         // 如果最后一个对象也被 delete,删除自身   
  22.         if(owners.size() == 0)   
  23.            delete this;   
  24.        }     
  25.    private:   
  26.        QList owners;   
  27. ;  

        现在我们的实现已经可以做到防止一个对象多次调用 attach() 和 detach() 了。然而,还有一个问题是,我们不能保证对象一定会调用 attach() 函数进行注册。毕竟,这不是 C++ 内置机制。有一个解决方案是,重定义 new 运算符(这一实现同样很复杂,不过可以避免出现有对象不调用 attach() 注册的情况)。

 

四、总结

      Qt 简化了我们对内存的管理,但是,由于它会在不太注意的地方调用 delete,所以,使用时还是要当心。

 

五、参考

 









以上是关于Qt浅谈内存泄露(总结)的主要内容,如果未能解决你的问题,请参考以下文章

前端内存泄露浅谈

qt编程,怎么能避免内存泄露

log4qt内存泄露问题,heob内存检测工具的使用

log4qt内存泄露问题,heob内存检测工具的使用

Qt中内存泄露和退出崩溃的问题 delete

ios instruments怎么检测内存泄露