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
  }
}

void parentObjectClass::onButtonClick(){
  QDialog dialog(this);
  if(dialog.exe()){
    // do something
  }
}

To copy to clipboard, switch view to plain text mode 

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
  }
}

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

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

void parentObjectClass::onButtonClick(){
  dialog->setDialog(values);
  if(dialog->exe()){
    // do something
  }
}

To copy to clipboard, switch view to plain text mode 

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;
}

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

To copy to clipboard, switch view to plain text mode 

// header
Class parentObjectClass{
  //....
  QDialog dialog;
  //...
};
 
// cpp
parentObjectClass::parentObjectClass() : dialog(this) {
}
 
void parentObjectClass::onButtonClick(){
  dialog.setDialog(values);
  if(dialog.exec()){
    // do something
  }
}

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

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

void parentObjectClass::onButtonClick(){
  dialog.setDialog(values);
  if(dialog.exec()){
    // do something
  }
}

To copy to clipboard, switch view to plain text mode 

(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.