Russian Qt Forum

MyClass* p = new MyClass;
...
//do something
...
delete p;
p = 0;
...
if(p){
//действия с объектом через указатель
}
delete p;//p == 0, ничего не случится

QList <int> lst;
for (int i = 0; i < 1024 * 1024; ++i)
 lst.append(i);
...
lst.clear();  // это не освободит память

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>

class QTextEdit;
class QComboBox;

class widget:public QWidget
{
    Q_OBJECT
public:
    widget(QWidget *parent=0);
    ~widget();
    QTextEdit *text;
    QComboBox *combo;

private slots:
    void crash();
};

#endif // WIDGET_H

#include <QtGui>
#include "widget.h"

widget::widget(QWidget *parent):QWidget(parent)
{
    text=new QTextEdit(this);
    combo=new QComboBox(this);
    qDebug()<<connect(text,SIGNAL(destroyed()),this,SLOT(crash()));
    qDebug()<<connect(combo,SIGNAL(destroyed()),this,SLOT(crash()));
}

void widget::crash()
{
    static int num=0;
    qDebug()<<"Crashed number "+QString::number(num);
    ++num;
}

widget::~widget()
{
    qDebug()<<"Widget Crashed!";
}

#include <QtGui>
#include "widget.h"

int main(int argc,char* argv[])
{
    QApplication app(argc,argv);
    widget w;
    w.show();
    app.exec();
    return 0;
}

QObject::~QObject()
{
    .....
    if (!d->children.isEmpty())
        d->deleteChildren();

    qt_removeObject(this);
    .....
}

void QObjectPrivate::deleteChildren()
{
    const bool reallyWasDeleted = wasDeleted;
    wasDeleted = true;
    // delete children objects
    // don't use qDeleteAll as the destructor of the child might
    // delete siblings
    for (int i = 0; i < children.count(); ++i) {
        currentChildBeingDeleted = children.at(i);
        children[i] = 0;
        delete currentChildBeingDeleted;
    }
    children.clear();
    currentChildBeingDeleted = 0;
    wasDeleted = reallyWasDeleted;
}

virtual ~QObject();

class Foo: public QObject{
	enum{size = 100};
	int* m_data;
public:
	Foo(QObject* pobj = 0):QObject(pobj){
		m_data = new int[size];
	}
	~Foo(){
		delete []m_data;
		std::cout << "Foo destructor" << std::endl;
	}
};
int main(int argc, char *argv[])
{
	QObject* pobj = new Foo;
	//do something...
	delete pobj;//вызывается деструктор Foo
}

QObject* pobj = new Foo;

Foo* pobj = new Foo;

typedef QList<QObject*> QObjectList;

void QObjectPrivate::deleteChildren()
{
    ......
    for (int i = 0; i < children.count(); ++i) {
        currentChildBeingDeleted = children.at(i);
        children[i] = 0;
        delete currentChildBeingDeleted;//вот здесь
    }
    ......
}

if (!d->children.isEmpty())
        d->deleteChildren();

class MyLabel : public QLabel {
 public:
  MyLabel( const QString & txt, QWidget * parent = 0 ) : QLabel(txt, parent) {}
 ~MyLabel( void ) { qDebug() << "MyLabel destroyed"; }
};

class Foo{
	enum{size = 100};
	int* m_data;
public:
	Foo(){
		m_data = new int[size];
	}
	virtual ~Foo(){
		delete []m_data;
	}
};

class Foo{
	enum{size = 100};
	int* m_data;
public:
	Foo(){
		m_data = new int[size];
	}
	virtual ~Foo(){
		delete []m_data;
		std::cout<< "Foo destructor" << std::endl;
	}
};
class Derived1: public Foo{
	int x;
public:
	Derived1():Foo(),x(0){}
	virtual ~Derived1(){
		std::cout << "Derived1 destructor" << std::endl;
	}
};
class Derived2: public Foo{
	int* m_d;
public:
	Derived2():Foo(),m_d(0){
		m_d = new int(1);
	}
	virtual ~Derived2(){
		delete m_d;
		std::cout << "Derived2 destructor" << std::endl;
	}
};
int main(int argc, char *argv[])
{
	Derived1 *pd1 = new Derived1;
	Derived2 *pd2 = new Derived2;
	//do something...
	delete pd1;
	delete pd2;
}

QHash<int,A*> values_;

//Stack.h
#ifndef STACK_H
#define STACK_H

#include "ObjectsHierarchy.h"

class Stack{
	struct Node{
		Object* data;
		Node* next;
		Node(Object* _data, Node* _next): data(_data), next(_next){}
	}* top;
public:
	Stack():top(0){}
	~Stack(){
		//контейнер Stack не является владельцем объектов типа Object - за их создание и удаление
		//отвечает код, использующий экземпляр класса Stack. Удаляются только узлы Node
		while(top) pop();
	}
	void push(Object* _data){
		top = new Node(_data, top);
	}
	Object* peek() const{
		return (top ? top->data : 0);
	}
	Object* pop(){
		if(top == 0) return 0;
		Object* result = top->data;
		Node* oldTop = top;
		top = top->next;
		delete oldTop;
		return result;
	}
};

#endif //STACK_H

//ObjectsHierarchy.h
#ifndef OBJECT_HIERARCHY_H
#define OBJECT_HIERARCHY_H

#include <iostream>

typedef unsigned char byte;
typedef unsigned int uint;
const unsigned int default_size = 100;

class Object{
public:
	Object(){}
	virtual ~Object(){
		std::cout<< "Object destructor" << std::endl;
	}
	virtual char* presentation() = 0;
};

class Derived1: public Object{
	byte *m_data;
public:
	Derived1(uint size = default_size): Object(){
		m_data = new byte[size];
	}
	virtual ~Derived1(){
		delete []m_data;
		std::cout << "Derived1 destructor" << std::endl;
	}
	char* presentation(){return "I'm class Derived1";}
	static Derived1* create(uint size = default_size){
		return new Derived1(size);
	}
	void remove(){
		delete this;
	}
};

class Derived2: public Object{
	byte *m_data;
public:
	Derived2(uint size = default_size): Object(){
		m_data = new byte[size];
	}
	virtual ~Derived2(){
		delete []m_data;
		std::cout << "Derived2 destructor" << std::endl;
	}
	char* presentation(){return "I'm class Derived2";}
	static Derived2* create(uint size = default_size){
		return new Derived2(size);
	}
	void remove(){
		delete this;
	}
};
#endif //OBJECT_HIERARCHY_H

//main.cpp

#include <iostream>
#include "Stack.h"
#include "ObjectsHierarchy.h"

int main(){
	Stack st;
	//заполняем контейнер разнородными объектами
	for(uint i = 0; i < 5; i++){
		st.push(Derived1::create(i*10));
	}
	for(uint i = 5; i < 10; i++){
		st.push(Derived2::create(i*10));
	}
	st.push(new Derived1(1000));//до кучи
	Object* p = 0;
	while(p = st.pop()){
		//унифицированно работаем с объектами через их общий интерфейс
		std::cout << p->presentation() << std::endl;
		//удаляем больше не нужные объекты
		delete p;//работает виртуальный деструктор
	}

	return 0;
}

//EditWindow производный от QGraphicsView в нем scene

void EditWindow::dropEvent(QDropEvent *event) 
{
    QComboBox *X = new QComboBox();                //Здесь я не пойму кокого parent-ом указать
    d->addItem("0");
    d->addItem("1");
    QGraphicsProxyWidget *proxy = scene->addWidget(d);  //Судьба *X мне известна, автоматом  
    proxy->setPos(event->pos().x(), event->pos().y());  //он не удалится
}