Question

I have an application that opens a QDialog for some flow, and when it is closed, the QMainWindow is opened.

In the QDialog I create some objects that I’d like to pass as a pointer (or some other way) to the QMainWindow. For example I create a SysTray object that needs to change its state from the QMainWindow. What is the best way? Singletons?

update .
after implementing the sulotion another question was rises , does the QDialog is cleaned from memory that means , invoked its destructor ? i don’t think its the case . i have to do some object cleaning , and there destructor never invoked

Answer 1

One approach is to allocate on the heap with the QMainWindow as a parent. The QObject-hierarchy will take care of freeing the memory and you will access the object for the lifetime of the QMainWindow.

If at any point you know for sure that you don’t need the QDialog or the shared object anymore, you can call deleteLater.

Example:

class MyDialog : public QDialog
{
    Q_OBJECT

    QObject* _objToShare;

public:    
    QObject* objToShare() const { return _objToShare; }

    MyDialog(QObject* parent = 0) : QDialog(parent)
    {
        _objToShare = new QObject(this); // either use this as the parent
                                         // or free by hand in the destructor
    }

    // ...
 };

 class MyWindow : public QMainWindow
 {
     Q_OBJECT
     // ...

     QObject* ptrToSharedObj; // alternatively you can hold a pointer
                              // to your MyDialog instance
 };

Where you use your QDialog:

 MyDialog* d = new MyDialog(this);
 d->exec();
 ptrToSharedObj = d->objToShare();
 // don't delete d explicitly, the QObject hierarchy will take care of that

A better (and likely more memory-friendly) approach is to use a shared pointer implementation. Qt has a variety of smart pointer classes, one of which is QSharedPointer. It is basically a thread-safe, reference-counted pointer which means that if you grab one that points to the shared object of your QDialog, it will not get freed as long as there are any other QSharedPointers pointing to it. Keep in mind that this might cause circular references if you are not careful.

Example:

class MyDialog : public QDialog
{
    Q_OBJECT

    QSharedPointer<QObject> _objToShare; 
                                 // ^ don't delete in the destructor
public:

    QSharedPointer<QObject> objToShare() const { return _objToShare; }

    MyDialog(QObject* parent = 0) : QDialog(parent)
    {
        _objToShare = QSharedPointer<QObject>(new QObject); 
        // no parent to avoid destruction when the dialog is destructed
    }

    // ...
 };

 class MyWindow : public QMainWindow
 {
     Q_OBJECT
     // ...

     QSharedPointer<QObject> ptrToSharedObj;
 };

Where you use your QDialog:

MyDialog d;
d.exec();
ptrToSharedObj = d.objToShare(); 

From this point on, even if d goes out of scope (i.e. destroyed), you will still have a valid pointer to the shared data (well, of course unless you do something explicitly to invalidate it).