QT中手动释放堆中的对象（new 出来的）...

Qt内存自动释放有两个前提条件：1. 必须是QObject的派生类 2.必须指定了parent对象 即：Qt 中 父亲被删除的时候会自动销毁他的孩子。所以如果New出来的并且没有父亲。那么则需要手动删除它。需要，不然那块空间就一直占用了

 QLabel* lb=new QLabel();

    delete (lb);

    if(lb==NULL)

    {

    }

    delete(this);//this是继承Qweiget基类的子控件，当new出来此控件后，想要彻底释放此子控件，需这样用delete手动释放，

                               //用delete释放后可触发此控件类的析构函数彻底释放相关ui资源，可通过断点观察

如果是自己 new 出来的, delete 掉就好了.
如果不是new 出来的, 就不用管. qt 会自己释放掉.

QT 关闭窗口是否销毁窗口及子部件

顶层窗口调用close：应用程序销毁该窗口部件及子部件。

非顶层窗口close：关闭时只是隐藏，不会被销毁。

qt对象销毁过程delete

在C++中学习过程中，我们都知道：

• delete 和 new 必须配对使用(一 一对应)：delete少了，则内存泄露，多了麻烦更大。

Qt作为C++的库，显然是不会违背C++的前述原则的。可是:

• 在Qt中，我们很多时候都疯狂地用new，却很少用delete，缺少的 delete 去哪儿了？！

注：本文暂不涉及智能指针(smart pointer)相关的东西，你可以考虑 Qt 智能指针学习 一文

Qt半自动的内存管理

在Qt中，以下情况下你new出的对象你可以不用亲自去delete (但你应该清楚delete在何处被Qt调用的，怎么被调用的)：

• QObject及其派生类的对象，如果其parent非0，那么其parent析构时会析构该对象(本文内容围绕这一点展开)

除此之外，有些类的对象可以接收设置一些特别的标记，比如：

• QWidget及其派生类的对象，可以设置 Qt::WA_DeleteOnClose 标志位(当close时会析构该对象)
• QAbstractAnimation派生类的对象，可以设置 QAbstractAnimation::DeleteWhenStopped
• QRunnable::setAutoDelete()
• MediaSource::setAutoDelete()
• ...

注意：这些用法会有些陷阱，请注意看本文最后的3个小例子。

在Qt中，最基础和核心的类是：QObject 。它的魔力很大，本文只关注两点：

• 父子关系
• deleteLater

父子关系

在Qt中，每个 QObject 内部都有一个list，用来保存所有的 children，还有一个指针，保存自己的parent。当它自己析构时，它会将自己从parent的列表中删除，并且析构掉所有的children。

• 注意：在 Qt 中，我们经常会遇到
  • 基类、派生类，或父类、子类。这是对于派生体系来说的，和在C++相关书中看到的完全一样，与这的parent无关
  • 父对象、子对象、父子关系。这是Qt中所特有的，也就是这儿的parent所引入的，与类的继承关系无关

建立与解除

Q_INVOKABLE QObject::QObject ( QObject * parent = 0 )

• 创建一个QObject对象时，如果指定了父对象，它就会将自己添加到父对象的 children 列表中

QObject::~QObject () [virtual]

• 当一个QObject对象析构时，它会将自己从父对象的 children 列表中移除(parent非0的话)

void QObject::setParent ( QObject * parent )

• 通过该函数，将自己从原父对象的children中删除，添加到新parent的children列表中

注：这三个函数都是通过一个内部私有函数来实现的，这就是

QObjectPrivate::setParent_helper(QObject *o)

获取父、子对象

每个QObject只有一个父对象：

QObject * QObject::parent () const

子对象可以有多个

const QObjectList & QObject::children () const

所以可以根据条件来查找喽：

T QObject::findChild ( const QString & name = QString() ) const
QList<T> QObject::findChildren ( const QString & name = QString() ) const

deleteLater

deleteLater 包含两层意思了

• delete
• later

呵呵，似乎这是废话哈。

删除自己

在去年春节前的时候吧，有人对

obj-> deleteLater()

会像下面一样调用delete：

delete obj;

感到不解。然后我写了这样一个C++例子：

class A
{
  public:
  A(){}
  void deleteMe()
  {
      delete this;
  }
};

int main()
{
  A * a = new A;
  a->deleteMe();
  return 0;
} 

应该不需要解释吧

later

Qt 是事件驱动的，所以发送一个删除事件到事件系统就可以啦：

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

事件循环稍后看到该事件就会将其派发会这个widget：

bool QObject::event(QEvent *e)
{
    switch (e->type()) {
...
    case QEvent::DeferredDelete:
         ...

一些例子

无关痛痒？

很简短、很熟悉的一个例子是不？但是 如果你发现对象的析构函数始终不被成功调用，会有什么感觉？

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

这是 C++ GUI Programming with Qt 4 一书的第一个例子。我们注意到这儿的 label 既没有指定parent，也没有对其调用delete。

所以，这儿会造成内存泄露。

书中解释说，对于这种小例子，这点内存泄露不算什么。不清楚官方这个例子的意图是什么，或许是一开始就让大家用指针吧。

三种改进方式

• 分配对象到stack而不是heap中

QLabel label("Hello Qt!");
label.show();

• 设置标志位，这样，当我们点击关闭按钮时，close()函数将会调用deleteLater

label->setAttribute(Qt::WA_DeleteOnClose);

• 动手调用delete(不就是少了一个么，我们补上还不行么)

int ret = app.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对象却不是通过new分配到heap中的。

为了使得用户减少自己显式使用delete，Qt将delete隐藏的比较深。这样一来，不使用new为对象分配空间时，反倒需要多多小心了。

隐蔽很深？

看个小例子：这个程序退出时会直接崩溃。

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

• 问题出在哪儿呢？因为退出时，w 比 label 先被析构，当 w 被析构时，会删除chilren列表中的对象，也就是这儿的 label。但 label 却不是通过new分配在heap中，而是在stack中，可想而知，delete 一个再stack中的对象会怎么样了。相当于

QLabel label();
delete &label;

• 两种改进办法：
  • 一是，将label分配到heap中

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

• 再一种就是，确保label先于其parent被析构(调整一下顺序)，这样，label析构时将自己从父对象的列表中移除自己，w析构时，children列表中就不会有分配在stack中的对象了。

   QWidget w;
   QLabel label(tr"Hello Qt!");

Qt 对象的父子关系的引入，简化了我们对内存的管理，但是，由于它会在你不太注意的地方调用 delete，所以，使用时还是要当心。

QT中 自己new的QSound对象如何销毁

自己delete是可以的

不过qt对于内存管理是很方便的。他可以在父对象删除时自动删除子对象，而不需要你去关心内存的释放。
所以你只要设置了父子关系就可以不用管什么时候销毁了。
把this指针传给他
QSound *snd=new QSound(this);

Qt中对象销毁的几种用法

1. 生成对象时指定了parent, 且此对象是QObject，则parent会接管此对象的销毁工作。
即只用new不用delete, 当parent在销毁时会自动将这个子对象进行合适的销毁。

由于自动销毁，至于如果使用deleteLater();这种重复删除，会不会和Qt自动销毁的机制有冲突？这个就没研究明白了。

2. 生成对象时使用了QPointer, 在删除时应使用
XX.deleteLater(); 并且之后的一条语句一定不要 用XX=NULL;(因为deleteLater()非阻塞，并非马上删除，此时如果置XX=NULL了，可能Qt发现已经是NULL将不再删除此对象，造成内存泄露)

3. 当使用普通的C++指针，请用传统的delete
if(NULL != XX) {delete XX;  XX = NULL;}

 

我们都知道C++中的new和delete是需要成对存在的，否则会导致内存泄漏。但是，在QT中，有的时候我们new出来的对象，并不需要delete也会释放掉。那么，究竟什么时候需要手动释放，什么时候不需要释放，交给QT自动释放呢？

##2.QT的自动释放机制
在QT基础 - QObject简介一文中提到：
QObject在对象树中组织自己。当你用另一个对象作为父对象创建一个QObject时，对象将自动添加到父对象的children()列表中。父母拥有对象的所有权;即它会自动删除其子析构器中的子元素。

因此，我们可以得出如下结论：
当且仅当一个对象满足如下条件：
1.该对象是QObject的派生类
2.该对象的父类不为NULL
那么，该对象的父类删除时，该对象会被自动删除，无需手动释放。

##3.结论
当且仅当一个对象满足如下条件：
1.该对象是QObject的派生类
2.该对象的父类不为NULL
那么，该对象的父类删除时，该对象会被自动删除，无需手动释放。

C/C++内存分配方式与存储区

C/C++内存分配有三种方式：
[1]从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。
[2]在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。
栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
[3]从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。
动态内存的生存期由程序员决定，使用非常灵活，但如果在堆上分配了空间，就有责任回收它，否则运行的程序会出现内存泄漏，
频繁地分配和释放不同大小的堆空间将会产生堆内碎块。


C/C++程序编译时内存分为5大存储区：
1.栈区（stack） --编译器自动分配释放，主要存放函数的参数值，局部变量值等；
2.堆区（heap） --由程序员分配释放；
3.全局区或静态区 --存放全局变量和静态变量；程序结束时由系统释放，分为全局初始化区和全局未初始化区；
4.字符常量区 --常量字符串放与此，程序结束时由系统释放；
5.程序代码区--存放函数体的二进制代码
例： //main.c
int a=0; //全局初始化区
char *p1; //全局未初始化区
void main()
{
int b; //栈
char s[]="bb"; //栈
char *p2; //栈
char *p3="123"; //其中，“123\0”常量区，p3在栈区
static int c=0; //全局区
p1=(char*)malloc(10); //10个字节区域在堆区
strcpy(p1,"123"); //"123\0"在常量区，编译器 可能 会优化为和p3的指向同一块区域
｝


一个C程序占用的内存可分为以下几类：
(一) 栈
这是由编译器自动分配和释放的区域。主要存储函数的参数，函数的局部变量等。当 
一个函数开始执行时，该函数所需的实参，局部变量就推入栈中，该函数执行完毕 
后，之前进入栈中的参数和变量等也都出栈被释放掉。它的运行方式类似于数据结构 
中的栈。
(二) 堆
这是由程序员控制分配和释放的区域，在C里，用malloc()函数分配的空间就存在于堆 
上。在堆上分配的空间不像栈一样在某个函数执行完毕就自动释放，而是一直存在于 
整个程序的运行期间。当然，如果你不手动释放(free()函数)这些空间，在程序运行 
结束后系统也会将之自动释放。对于小程序来说可能感觉不到影响的存在，但对于大 
程序，例如一个大型游戏，就会遇到内存不够用的问题了。
(三) 全局区
C里的全局变量和静态变量存储在全局区。它们有点像堆上的空间，也是持续存在于程
序的整个运行期间，但不同的是，他们是由编译器自己控制分配和释放的。
(四) 文字常量区
例如char *c = “123456”；则”123456”为文字常量，存放于文字常量区。也由编译器 
控制分配和释放。
(五) 程序代码区
存放函数体的二进制代码。


2． 例子(一)
int a = 0; //全局区
void main()
{
int b; //栈
char s[] = "abc"; //s在栈,"abc"在文字常量区
char *p1,*p2; //栈
char *p3 = "123456"; //"123456"在常量区，p3在栈上
static int c =0; //全局区
p1 = (char *)malloc(10); //p1在栈，分配的10字节在堆
p2 = (char *)malloc(20); //p2在栈，分配的20字节在堆
strcpy(p1, "123456"); //"123456"放在常量区


//编译器可能将它与p3所指向的"123456"优化成一个地方。
}


3． 例子(二)
//返回char型指针
char *f()
{
//s数组存放于栈上
char s[4] = {'1','2','3','0'};
return s; //返回s数组的地址，但程序运行完s数组就被释放了
}
void main()
{
char *s;
s = f();
printf ("%s", s); //打印出来乱码。因为s所指向地址已经没有数据
}


还有就是函数调用时会在栈上有一系列的保留现场及传递参数的操作。 
栈的空间大小有限定，vc的缺省是2M。栈不够用的情况一般是程序中分配了大量数组和递归函数层次太 
深。有一点必须知道，当一个函数调用完返回后它会释放该函数中所有的栈空间。
栈是由编译器自动管理的，不用你操心。 
堆是动态分配内存的，并且你可以分配使用很大的内存。但是用不好会产生内存泄漏。 
并且频繁地malloc和free会产生内存碎片（有点类似磁盘碎片），因为c分配动态内存时是寻找匹配的 
内存的。而用栈则不会产生碎片。 
在栈上存取数据比通过指针在堆上存取数据快些。 
一般大家说的堆栈和栈是一样的，就是栈(stack)，而说堆时才是堆heap. 
栈是先入后出的，一般是由高地址向低地址生长。 


转载的另外一篇： 


堆(heap)和栈(stack)是C/C++编程不可避免会碰到的两个基本概念。首先，这两个概念都可以在讲数据 
结构的书中找到，他们都是基本的数据结构，虽然栈更为简单一些。 
在具体的C/C++编程框架中，这两个概念并不是并行的。对底层机器代码的研究可以揭示，栈是机器系 
统提供的数据结构，而堆则是C/C++函数库提供的。 
具体地说，现代计算机(串行执行机制)，都直接在代码底层支持栈的数据结构。这体现在，有专门的寄 
存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作。 
这种机制的特点是效率高，支持的数据有限，一般是整数，指针，浮点数等系统直接支持的数据类型， 
并不直接支持其他的数据结构。因为栈的这种特点，对栈的使用在程序中是非常频繁的。对子程序的调 
用就是直接利用栈完成的。机器的call指令里隐含了把返回地址推入栈，然后跳转至子程序地址的操 
作，而子程序中的ret指令则隐含从堆栈中弹出返回地址并跳转之的操作。C/C++中的自动变量是直接利 
用栈的例子，这也就是为什么当函数返回时，该函数的自动变量自动失效的原因。 


和栈不同，堆的数据结构并不是由系统(无论是机器系统还是操作系统)支持的，而是由函数库提供的。 
基本的malloc/realloc/free函数维护了一套内部的堆数据结构。当程序使用这些函数去获得新的内存 
空间时，这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以使用的内存空间，则试图利 
用系统调用来动态增加程序数据段的内存大小，新分配得到的空间首先被组织进内部堆中去，然后再以 
适当的形式返回给调用者。当程序释放分配的内存空间时，这片内存空间被返回内部堆结构中，可能会 
被适当的处理(比如和其他空闲空间合并成更大的空闲空间)，以更适合下一次内存分配申请。这套复杂 
的分配机制实际上相当于一个内存分配的缓冲池(Cache)，使用这套机制有如下若干原因： 


1. 系统调用可能不支持任意大小的内存分配。有些系统的系统调用只支持固定大小及其倍数的内存请 
求(按页分配)；这样的话对于大量的小内存分类来说会造成浪费。 
2. 系统调用申请内存可能是代价昂贵的。系统调用可能涉及用户态和核心态的转换。 
3. 没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片。 


堆和栈的对比 


从以上知识可知，栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而堆是函数库 
提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。栈是系统数据结构，对于进 
程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。不同堆分配的内存无法互相操作。栈空间 
分静态分配和动态分配两种。静态分配是编译器完成的，比如自动变量(auto)的分配。动态分配由 
alloca函数完成。栈的动态分配无需释放(是自动的)，也就没有释放函数。为可移植的程序起见，栈的 
动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回 
系统，但是精确的申请内存/释放内存匹配是良好程序的基本要素。