Performance comparison of QDialog on stack and heap

[Seishin]

Hi everyone,

I read some articles about memory allocation and free in Qt recently. And I have question about the performance of creating QDialogs on stack (non-pointer) vs on heap (new).

For stack, we just recreate the dialog every time and it should be auto-deleted after we close it, like

void parentObjectClass::onButtonClick(){
QDialog dialog(this);
if(dialog.exe()){
// do something
}
}
I think this one will auto delete the dialog instance every time after the dialog is closed. But every time the dialog need to be re-initialized.

For heap, we pre-initialize the object and reuse it every time, like


// header
Class parentObjectClass{
//....
QDialog *dialog;
//...
};

// cpp
void parentObjectClass::initialize(){
dialog = new QDialog(this);
}

void parentObjectClass::onButtonClick(){
dialog->setDialog(values);
if(dialog->exe()){
// do something
}
}
This one just reset the dialog contents every time, but if we have a lot of dialogs, we have to initialize all of them when parentObjectClass instance is created, and they will occupy memory until parentObject is deleted.

Am I right? And which way is better for practical using?
Thanks.

[yeye_olive]

Your question is not really about stack-based vs heap-based allocation, but about creating and destroying dialogs everytime they are show and closed vs reusing them. Indeed, your examples can be rewritten to use the opposite allocation strategy:


void parentObjectClass::onButtonClick(){
QDialog *dialog = new QDialog(this);
if(dialog->exec()){
// do something
}
delete dialog;
}


// header
Class parentObjectClass{
//....
QDialog dialog;
//...
};

// cpp
parentObjectClass::parentObjectClass() : dialog(this) {
}

void parentObjectClass::onButtonClick(){
dialog.setDialog(values);
if(dialog.exec()){
// do something
}
}
(note that in the second snippet dialog is not necessarily allocated on the stack, it is just allocated in the same memory block as the parentObjectClass.)

Now, about your question. I have no strong opinion on the subject. Does it really have a noticeable impact on the performance of your program? One interesting thing to notice is that by reusing a dialog you preserve its state (position and size) while you need to explicitly store it and re-apply it if you use distinct instances.

[Seishin]

Yes I agree. Usually this won't have a big difference. Actually reusing a dialog make the dialog show immediately after the first showing. This should make user feel the difference. (The dialog looks like switching to a hidden window but not popping up.) And plus it keeps the old status as you said, I do think it should be better to recreate the dialog.