Qt浅谈之一：内存泄露（总结）

https://blog.csdn.net/taiyang1987912/article/details/29271549

1、简介

       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。
2、关联图

（1）Linux内存图，主要了解堆栈上分配内存的不一样方式。


（2）在Qt中，最基础和核心的类是：QObject，QObject内部有一个list，会保存children，还有一个指针保存parent，当本身析构时，会本身从parent列表中删除而且析构全部的children。

3、详解

一、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无关）。

二、内存问题例子

    例子一

    #include <QApplication>
    #include <QLabel>
     
    int main(int argc, char *argv[])
    {
        QApplication a(argc, argv);
        QLabel *label = new QLabel("Hello Qt!");
        label->show();
        return a.exec();
    }

分析：（1）label 既没有指定parent，也没有对其调用delete，因此会形成内存泄漏。书中的这种小例子也会出现指针内存的问题。
改进方式：（1）分配对象到栈上而不是堆上

    #include <QApplication>
    #include <QLabel>
     
    int main(int argc, char *argv[])
    {
        QApplication a(argc, argv);
        QLabel label("Hello Qt!");
        label.show();
        return a.exec();
    }

（2）设置标志位，close()后会delete label。

label->setAttribute(Qt::WA_DeleteOnClose);

（3）new后手动delete

    #include <QApplication>
    #include <QLabel>
     
    int main(int argc, char *argv[])
    {
        int ret = 0;
        QApplication a(argc, argv);
        QLabel *label = new QLabel("Hello Qt!");
        label->show();
        ret = a.exec();
        delete label;
        return ret;
    }

    例子二

    #include <QApplication>
    #include <QLabel>
    int main(int argc, char *argv[])
    {
        QApplication app(argc, argv);
        QLabel label("Hello Qt!");
        label.show();
        label.setAttribute(Qt::WA_DeleteOnClose);
        return app.exec();
    }

运行：

分析：程序崩溃，由于label被close时，delete &label;但label对象是在栈上分配的内存空间，delete栈上的地址会出错。

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

    例子三

    #include <QApplication>
    #include <QLabel>
    int main(int argc, char* argv[])
    {
       QApplication app(argc, argv);
       QLabel label("Hello Qt!");
       QWidget w;
       label.setParent(&w);
       w.show();
       return app.exec();
    }


分析：Object内部有一个list，会保存children，还有一个指针保存parent，当本身析构时，会本身从parent列表中删除而且析构全部的children。

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

改进方式：（1）调整一下顺序，确保label先于其parent被析构，label析构时将本身从父对象的列表中移除本身，w析构时，children列表中就不会有分配在stack中的对象了。

    #include <QApplication>
    #include <QLabel>
    int main(int argc, char* argv[])
    {
       QApplication app(argc, argv);
       QWidget w;
       QLabel label("Hello Qt!");
       label.setParent(&w);
       w.show();
       return app.exec();
    }


（2）将label分配到堆上

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

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

    例子四：野指针

    #include <QApplication>
    #include <QLabel>
    int main(int argc, char* argv[])
    {
       QApplication app(argc, argv);
       QWidget *w = new QWidget;
       QLabel *label = new QLabel("Hello Qt!");
       label->setParent(w);
       w->show();
       delete w;
       label->setText("go");     //野指针
       return app.exec();
    }

（上述程序不显示Label，仅做测试）

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

改进方式：QPointer智能指针

    #include <QApplication>
    #include <QLabel>
    #include <QPointer>
    int main(int argc, char* argv[])
    {
       QApplication app(argc, argv);
       QWidget *w = new QWidget;
       QLabel *label = new QLabel("Hello Qt!");
       label->setParent(w);
       QPointer<QLabel> p = label;
       w->show();
       delete w;
       if (!p.isNull()) {
         label->setText("go");
       }
       return app.exec();
    }

    例子五：deleteLater

      当一个QObject正在接受事件队列时若是中途被你销毁掉了，就是出现问题了，因此QT中建你们不要直接Delete掉一个QObject，若是必定要这样作，要使用QObject的deleteLater()函数，它会让全部事件都发送完一切处理好后立刻清除这片内存，并且就算调用屡次的deletelater也不会有问题。

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

    void QObject::deleteLater()
    {
        QCoreApplication::postEvent(this, new QEvent(QEvent::DeferredDelete));
    }

三、智能指针

        若是没有智能指针，程序员必须保证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 判断就为空了。

        // QPointer 表现相似普通指针
        QDate *mydate = new QDate(QDate::currentDate());
        QPointer mypointer = mydata;
        mydate->year();    // -> 2005
        mypointer->year(); // -> 2005
          
        // 当对象 delete 以后，QPointer 会有不一样的表现
        delete mydate;
          
        if(mydate == NULL)
            printf("clean pointer");
        else
            printf("dangling pointer");
        // 输出 dangling pointer
          
        if(mypointer.isNull())
            printf("clean pointer");
        else
            printf("dangling pointer");
        // 输出 clean pointer

（2）std::auto_ptr

        // QPointer 表现相似普通指针
        QDate *mydate = new QDate(QDate::currentDate());
        QPointer mypointer = mydata;
        mydate->year();    // -> 2005
        mypointer->year(); // -> 2005
          
        // 当对象 delete 以后，QPointer 会有不一样的表现
        delete mydate;
          
        if(mydate == NULL)
            printf("clean pointer");
        else
            printf("dangling pointer");
        // 输出 dangling pointer
          
        if(mypointer.isNull())
            printf("clean pointer");
        else
            printf("dangling pointer");
        // 输出 clean pointe

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

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

（3）其余的类参考相应文档。

四、自动垃圾回收机制
（1）QObjectCleanupHandler

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

    #include <QApplication>
    #include <QObjectCleanupHandler>
    #include <QPushButton>
     
    int main(int argc, char* argv[])
    {
       QApplication app(argc, argv);
       // 建立实例
       QObjectCleanupHandler *cleaner = new QObjectCleanupHandler;
       // 建立窗口
       QPushButton *w = new QPushButton("Remove Me");
       w->show();
       // 注册第一个按钮
       cleaner->add(w);
       // 若是第一个按钮点击以后，删除自身
       QObject::connect(w, SIGNAL(clicked()), w, SLOT(deleteLater()));
       // 建立第二个按钮，注意，这个按钮没有任何动做
       w = new QPushButton("Nothing");
       cleaner->add(w);
       w->show();
       // 建立第三个按钮，删除全部
       w = new QPushButton("Remove All");
       cleaner->add(w);
       QObject::connect(w, SIGNAL(clicked()), cleaner, SLOT(deleteLater()));
       w->show();
       return app.exec();
    }

       

      在上面的代码中，建立了三个仅有一个按钮的窗口。第一个按钮点击后，会删除掉本身（经过 deleteLater() 槽），此时，cleaner 会自动将其从本身的列表中清除。第三个按钮点击后会删除 cleaner，这样作会同时删除掉全部未关闭的窗口。

（2）引用计数
  应用计数是最简单的垃圾回收实现：每建立一个对象，计数器加 1，每删除一个则减 1。

    class CountedObject : public QObject
    {
        Q_OBJECT
    public:
        CountedObject()
        {
            ctr=0;
        }
      
        void attach(QObject *obj)
        {
            ctr++;
            connect(obj, SIGNAL(destroyed(QObject*)), this, SLOT(detach()));
        }
      
    public slots:
        void detach()
        {
            ctr--;
            if(ctr <= 0)
                delete this;
        }
      
    private:
        int ctr;
    };

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

（3）记录全部者

     更合适的实现是，不只仅记住有几个对象持有引用，并且要记住是哪些对象。例如：

     class CountedObject : public QObject
     {
        public:
           CountedObject() {}
          
           void attach(QObject *obj) {
             // 检查全部者
             if(obj == 0)
               return;
             // 检查是否已经添加过
             if(owners.contains(obj))
               return;
             // 注册
             owners.append(obj);
             connect(obj, SIGNAL(destroyed(QObject*)), this, SLOT(detach(QObject*)));
           }  
        public slots:
           void detach(QObject *obj) {
             // 删除
             owners.removeAll(obj);
             // 若是最后一个对象也被 delete，删除自身
             if(owners.size() == 0)
                delete this;
            }   
        private:
            QList owners;
    };

        如今咱们的实现已经能够作到防止一个对象屡次调用 attach() 和 detach() 了。然而，还有一个问题是，咱们不能保证对象必定会调用 attach() 函数进行注册。毕竟，这不是 C++ 内置机制。有一个解决方案是，重定义 new 运算符（这一实现一样很复杂，不过能够避免出现有对象不调用 attach() 注册的状况）。

4、总结
      Qt 简化了咱们对内存的管理，可是，因为它会在不太注意的地方调用 delete，因此，使用时仍是要小心。

5、参考

    http://doc.qt.nokia.com/4.7/qobject.html

    http://www.cuteqt.com/blog/?p=824
    http://blog.csdn.net/dbzhang800/article/details/6300025
    http://blog.csdn.net/dbzhang800/article/details/6403285
    http://devbean.blog.51cto.com/448512/526734/