Why do I have to dynamically allocate memory to QLabel for it to work?

Question

This code which does not dynamically allocate memory, does not show any label on the window.

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    QLabel l;
    l.setText ("cdsadsaf");
    l.setParent (this);
}

---

After dynamically allocating memory, the label shows up.

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    QLabel *label = new QLabel(this);
    label->setText("first line\nsecond line");
}

Why is dynamic memory allocation necessary for QLabel to work?

Answer 1

It's not required. You have typical scope problem here.

The first case creates the QLabel on the stack and it "dies" when you exit your constructor.

In the second it keeps on living 1)because it's dynamically allocated and 2)you actually assign a parent to it - that is your main window. If you don't do 2), the effect will be the same as with the first case but worse - you will create a memory leak:

Memory leak

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    QLabel *label = new QLabel(); # no parent
    label->setText("first line\nsecond line");
}

No memory leak due to a parent being assigned to the label

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    QLabel *label = new QLabel(this); # main window is the parent and will take care of destroying the label when its own destructor is called
    label->setText("first line\nsecond line");
}

You can avoid allocating the QLabel on the heap and yet still be able to use it by just moving it to a broader scope. Since your label is to be displayed in a main window, you can create a class member label. No dynamic allocation required because it will keep living as long as your window instance is alive.

class MainWindow : public QMainWindow
{
...
private:
  QLabel l;
}

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    this->l.setText ("cdsadsaf");
}

As mentioned in the comment (thanks again!) setParent(...) is not required here unless you want a parent-child relation for something else than memory management. See comments below.

Answer 2

This code which does not dynamically allocate memory, does not show any label on the window.

That's because the label goes out of scope as soon as you return from the constructor. The label's lifetime is annotated below. The label is a QLabel itself.

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    QLabel label;                // label is born
    label.setText ("cdsadsaf");  // label is alive
    label.setParent (this);      // label is alive
}                                // label dies

After dynamically allocating memory, the label shows up.

That's because the label doesn't go out of scope. The pointer to it does, but that doesn't matter. Note that label is merely a pointer, and the QLabel object exists independently of the pointer to it.

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    QLabel *label = new QLabel(this);          // label is born, QLabel is born
    label->setText("first line\nsecond line"); // label is alive, QLabel is alive
}                                              // label dies, QLabel is alive

Why is dynamic memory allocation necessary for QLabel to work?

It's not. You happened to give the QLabel a chance to stay alive as a consequence of using dynamic allocation, but that's just a coincidence.

You can make the label a part of the parent object itself - it won't necessitate a separate allocation then. The compiler will manage the memory for you.

#include <QtWidgets>

class MainWindow : public QMainWindow {
  QWidget m_central;
  QGridLayout m_layout{&m_central};
  QLabel m_label{"Hello, World"};
public:
  MainWindow(QWidget * parent = {}) : QMainWindow{parent} {
    m_layout.addWidget(&m_label, 0, 0);
    setCentralWidget(&m_central);
  }
};

int main(int argc, char ** argv) {
  QApplication app{argc, argv};
  MainWindow w;
  w.show();
  return app.exec();
}

Answer 3

When you create a QLabel on the stack, it gets deleted when the function returns. By the time the parent widget updates its display the QLabel is not around any longer.

Creating it on the heap allows it to live beyond the call to the function.