Correct way to finish QT app. Segmentation fault

I'm studiyng Qt and C++ and trying to make a simple Qt application. I don't understand how to destroy classes correctly. I need the destructor of MainWidget to be called to stop the timer. But when I try to delete MainWidget I'm getting "segmentation fault". Can somebody help to understand how to do this in right way?

GUI.cpp

#include "GUI.hpp"

Gui::Gui()
{
    led = new Led();
    mainWidget = new MainWidget();
    mainWidget->show();

    connect(this, SIGNAL(sendOneSignal()),
               mainWidget, SLOT(slotFunc()));
}

Gui::~Gui()
{

    delete led;
    //delete mainWidget; //segmentation error occurs
}

void Gui::func(void)
{
    emit sendOneSignal();
}

GUI.hpp

#ifndef __GUI_HEADER__
#define __GUI_HEADER__

#include "Led.hpp"
#include "MainWidget.hpp"

class Gui : public QObject
{
    Q_OBJECT

public:
    Gui();
    ~Gui();
    void func(void);
signals:
     void sendOneSignal(void);

private:
    Led *led;
    MainWidget *mainWidget;

};

typedef std::unique_ptr<Gui> GuiPtr;

#endif /* __GUI_HEADER__ */

MainWidget.cpp

#include "MainWidget.hpp"

MainWidget::MainWidget(QWidget *parent)
: QWidget(parent)
{
    setWindowModality(Qt::ApplicationModal);
    
    timer = new QTimer(this);
    connect(timer, &QTimer::timeout, this, &MainWidget::onTimeChanged);
    timer->start(1000);

    cardLabel = new QLabel();
    cardLabel->setAlignment(Qt::AlignRight|Qt::AlignTop);
    cardLabel->setPixmap(QPixmap(":/icons/img"));
}

MainWidget::~MainWidget()
{
    timer->stop();
    delete timer;
    delete cardLabel;
}

void MainWidget::onTimeChanged()
{
////
}

void MainWidget::slotFunc()
{
///
}

MainWidget.hpp

#ifndef MAINWINDOW_HPP
#define MAINWINDOW_HPP

//#include <QMainWindow>
#include <QTimer>
#include <QWidget>
#include <QFile>
#include <QLabel>
#include <QLayout>

typedef std::unique_ptr<QMessageBox> MessageBoxPtr;

class MainWidget : public QWidget
{
    Q_OBJECT

public:
    explicit MainWidget(QWidget *parent = nullptr);
    ~MainWidget();

protected slots:
    void slotFunc();

private slots:
    void onTimeChanged();

private:
    QLabel *cardLabel;
    QTimer *timer;
    QVBoxLayout *vbox;
    QHBoxLayout *hbox;
    bool isMessageBoxClosed = true;
};

#endif // MAINWINDOW_HPP

You don't have to delete a QWidget, or any other QObject, if it had a parent set. It will be done by parent's destruction.

That's the reason why studying Qt and C++ at same time is confusing. Qt throws out most of pudent C++ patterns out of window (not-a-widget), staying on very narrow subset of C++, until recently it was C++98, now it's C++11.

If you really wish to delete some parented or connected (signal\slot) QObject early or dynamically, you have to use deleteLater() method. The name is misleading, if possible it would delete immediately, but otherwise it will queue deletion until message pump finishes its cycle. For same reason you almost never should declate a QObject as a direct member of another QObject - default destructor behaviour would cause same problem.

Destructors would be called. Just not by you. The reason it's done this way is that the framework is multithreaded and parent will call methods ("slots") of a child object via signal\slot system. If you delete a child object, the parent would have a dangling pointer in its store.

So,t he root of the problem is creation of MainWidget. Because there is such code,

timer = new QTimer(this);
connect(timer, &QTimer::timeout, this, &MainWidget::onTimeChanged);

it should be either created with parent given:

mainWidget = new MainWidget(this); // can't be done here, this is not QWidget

or destroyed:

mainWidget->deleteLater();

Even connection to itself counts because event processing is global.

The problem here is: A Gui isn't a QWidget and a a QWidget cannot be parented to a QObject. It's rather unusual to have a QObject hosting widgets. It's normally done by a top-level widget.

NB: you shall not use GUI elements in other threads. If purpose of creating a host QObject was to pass\move it to a worker thread, there are more icebergs hiding in Qt on that route. IF not impossible, it's very inconvinient.