【Qt运行流程详解】从启动到事件循环的深入解读

#include <QApplication>
#include <QLabel>
int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    QLabel label("Hello, world!");
    label.show();
    return app.exec();
}

QApplication(int &argc, char **argv, int = ApplicationFlags);

QApplication(int &argc, char **argv, int = ApplicationFlags);
virtual ~QApplication();

static QStyle *style();
static void setStyle(QStyle*);
static QStyle *setStyle(const QString&);

using QGuiApplication::palette;
static QPalette palette(const QWidget *);
static QPalette palette(const char *className);
static void setPalette(const QPalette &, const char* className = nullptr);
static QFont font();
static QFont font(const QWidget*);
static QFont font(const char *className);
static void setFont(const QFont &, const char* className = nullptr);

static QWidgetList allWidgets();
static QWidgetList topLevelWidgets();
static QWidget *activeWindow();
static QWidget *widgetAt(const QPoint &p);
static QWidget *topLevelAt(const QPoint &p);

bool notify(QObject *, QEvent *) override;

static void beep();
static void alert(QWidget *widget, int duration = 0);
static void setCursorFlashTime(int);
static int cursorFlashTime();

Q_SIGNALS:
void focusChanged(QWidget *old, QWidget *now);

// QT_BEGIN_NAMESPACE 是一个宏，用于指明接下来的代码位于 Qt 的命名空间中
QT_BEGIN_NAMESPACE
// 引入 Qt 的字符串字面量命名空间，方便使用字符串操作
using namespace Qt::StringLiterals;
// 下面几行定义了跟踪宏，用于调试和性能分析
Q_TRACE_PREFIX(qtwidgets, "#include <qcoreevent.h>");
Q_TRACE_METADATA(qtwidgets, "ENUM { AUTO, RANGE User ... MaxUser } QEvent::Type;");
Q_TRACE_POINT(qtwidgets, QApplication_notify_entry, QObject *receiver, QEvent *event, QEvent::Type type);
Q_TRACE_POINT(qtwidgets, QApplication_notify_exit, bool consumed, bool filtered);
// 定义了一个宏，用于在静态函数中检查 QApplication 实例是否已创建
#define CHECK_QAPP_INSTANCE(...) \
    if (Q_LIKELY(QCoreApplication::instance())) { \
    } else { \
        qWarning("Must construct a QApplication first."); \
        return __VA_ARGS__; \
    }
// Qt 框架内部使用的导出函数，供框架其他部分调用
Q_CORE_EXPORT void qt_call_post_routines();
Q_GUI_EXPORT bool qt_sendShortcutOverrideEvent(QObject *o, ulong timestamp, int k, Qt::KeyboardModifiers mods, const QString &text = QString(), bool autorep = false, ushort count = 1);
// 定义 QApplicationPrivate 类的静态成员变量 self，用于存储 QApplicationPrivate 的实例
QApplicationPrivate *QApplicationPrivate::self = nullptr;
// 定义静态布尔变量 autoSipEnabled，可能与软件输入面板（SIP）的自动激活有关
bool QApplicationPrivate::autoSipEnabled = true;
// QT_END_NAMESPACE 用于结束 Qt 命名空间
QT_END_NAMESPACE

#include <QApplication>
#include <QPushButton>
int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    QPushButton button("Click me");
    button.show();
    return app.exec();
}

explicit QMainWindow(QWidget *parent = nullptr, Qt::WindowFlags flags = Qt::WindowFlags());
~QMainWindow();

QMenuBar *menuBar() const;
void setMenuBar(QMenuBar *menubar);
QStatusBar *statusBar() const;
void setStatusBar(QStatusBar *statusbar);
QWidget *centralWidget() const;
void setCentralWidget(QWidget *widget);

QByteArray saveState(int version = 0) const;
bool restoreState(const QByteArray &state, int version = 0);

// 声明 QMainWindowPrivate 类，它继承自 QWidgetPrivate。
class QMainWindowPrivate : public QWidgetPrivate
{
    // 使用 Q_DECLARE_PUBLIC 宏为 QMainWindowPrivate 类声明一个指向其公共接口的指针。
    Q_DECLARE_PUBLIC(QMainWindow)
public:
    // 默认构造函数
    inline QMainWindowPrivate()
        // 初始化列表
        : layout(nullptr),           // 初始化 layout 为 nullptr
          explicitIconSize(false),    // 初始化 explicitIconSize 为 false
          toolButtonStyle(Qt::ToolButtonIconOnly) // 初始化 toolButtonStyle 为 Qt::ToolButtonIconOnly
    // 针对 macOS 系统的特定代码
#ifdef Q_OS_MACOS
            , useUnifiedToolBar(false) // 初始化 useUnifiedToolBar 为 false
#endif
    { }
    // 类成员变量
    QMainWindowLayout *layout;        // 指向 QMainWindow 的布局管理器
    QSize iconSize;                   // 存储图标大小
    bool explicitIconSize;            // 标志位，表示图标大小是否被显式设置
    Qt::ToolButtonStyle toolButtonStyle; // 工具按钮的样式
    // 针对 macOS 系统的特定成员变量
#ifdef Q_OS_MACOS
    bool useUnifiedToolBar;            // 标志位，表示是否使用统一的工具栏样式
#endif
    // 初始化函数，用于进行进一步的初始化
    void init();
    // 静态内联函数，用于获取 QMainWindow 实例的布局
    static inline QMainWindowLayout *mainWindowLayout(const QMainWindow *mainWindow)
    {
        // 如果 QMainWindow 实例存在，返回其布局，否则返回 nullptr
        return mainWindow ? mainWindow->d_func()->layout : static_cast<QMainWindowLayout *>(nullptr);
    }
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    // 设置和显示主窗口等
    return app.exec();  // 启动事件循环
}

void MyWidget::mousePressEvent(QMouseEvent *event) {
    if (event->button() == Qt::LeftButton) {
        // 处理左键点击事件
    }
}

/*!
    Enters the main event loop and waits until exit() is called.  Returns
    the value that was passed to exit() (which is 0 if exit() is called via
    quit()).
    It is necessary to call this function to start event handling. The
    main event loop receives events from the window system and
    dispatches these to the application widgets.
    To make your application perform idle processing (by executing a
    special function whenever there are no pending events), use a
    QTimer with 0 timeout. More advanced idle processing schemes can
    be achieved using processEvents().
    We recommend that you connect clean-up code to the
    \l{QCoreApplication::}{aboutToQuit()} signal, instead of putting it in
    your application's \c{main()} function because on some platforms the
    exec() call may not return. For example, on Windows
    when the user logs off, the system terminates the process after Qt
    closes all top-level windows. Hence, there is no guarantee that the
    application will have time to exit its event loop and execute code at
    the end of the \c{main()} function after the exec()
    call.
    \sa quit(), exit(), processEvents(), QApplication::exec()
*/
int QCoreApplication::exec()
{
    // 检查 QCoreApplication 实例是否已创建
    if (!QCoreApplicationPrivate::checkInstance("exec"))
        return -1;
    // 获取当前线程的数据
    QThreadData *threadData = self->d_func()->threadData.loadAcquire();
    // 检查这个方法是否在主线程中被调用
    if (threadData != QThreadData::current()) {
        qWarning("%s::exec: Must be called from the main thread", self->metaObject()->className());
        return -1;
    }
    // 检查是否已有事件循环在运行
    if (!threadData->eventLoops.isEmpty()) {
        qWarning("QCoreApplication::exec: The event loop is already running");
        return -1;
    }
    // 设置标志，表示现在不应该退出事件循环
    threadData->quitNow = false;
    // 创建并进入一个新的事件循环
    QEventLoop eventLoop;
    self->d_func()->in_exec = true; // 标记 exec 正在运行
    self->d_func()->aboutToQuitEmitted = false;
    // 开始事件循环并等待它结束
    int returnCode = eventLoop.exec(QEventLoop::ApplicationExec);
    // 重置退出标志
    threadData->quitNow = false;
    // 如果 QCoreApplication 实例仍然存在，执行清理操作
    if (self)
        self->d_func()->execCleanup();
    // 返回事件循环的退出代码
    return returnCode;
}

class MyWidget : public QWidget {
    Q_OBJECT
public:
    MyWidget();
signals:
    void mySignal();
public slots:
    void mySlot();
};

QObject::connect(sender, &Sender::signal, receiver, &Receiver::slot);
QObject::disconnect(sender, &Sender::signal, receiver, &Receiver::slot);

#include <QFile>
#include <QDataStream>
#include <QTextStream>
#include <QString>
#include <QDebug>
/**
 * \brief Example class demonstrating file IO in Qt.
 *
 * This class provides a simple example of how to use QFile, QDataStream,
 * and QTextStream for reading from and writing to files. It includes methods
 * for reading and writing both text and binary data.
 */
class FileIOExample
{
public:
    /**
     * Reads text data from a file.
     *
     * \param fileName The name of the file to read from.
     * \return A QString containing the contents of the file.
     */
    QString readTextFile(const QString &fileName)
    {
        QFile file(fileName);
        if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
        {
            qWarning("Unable to open file for reading.");
            return QString();
        }
        QTextStream in(&file);
        QString fileContent = in.readAll();
        file.close();
        return fileContent;
    }
    /**
     * Writes text data to a file.
     *
     * \param fileName The name of the file to write to.
     * \param text The text to write into the file.
     */
    void writeTextFile(const QString &fileName, const QString &text)
    {
        QFile file(fileName);
        if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
        {
            qWarning("Unable to open file for writing.");
            return;
        }
        QTextStream out(&file);
        out << text;
        file.close();
    }
    /**
     * Reads binary data from a file.
     *
     * \param fileName The name of the file to read from.
     * \return A QByteArray containing the binary contents of the file.
     */
    QByteArray readBinaryFile(const QString &fileName)
    {
        QFile file(fileName);
        if (!file.open(QIODevice::ReadOnly))
        {
            qWarning("Unable to open file for reading.");
            return QByteArray();
        }
        QDataStream in(&file);
        QByteArray data;
        in >> data;
        file.close();
        return data;
    }
    /**
     * Writes binary data to a file.
     *
     * \param fileName The name of the file to write to.
     * \param data The binary data to write into the file.
     */
    void writeBinaryFile(const QString &fileName, const QByteArray &data)
    {
        QFile file(fileName);
        if (!file.open(QIODevice::WriteOnly))
        {
            qWarning("Unable to open file for writing.");
            return;
        }
        QDataStream out(&file);
        out << data;
        file.close();
    }
};

#include <QtSql/QSqlDatabase>
#include <QtSql/QSqlQuery>
#include <QtSql/QSqlError>
#include <QDebug>
#include <QVariant>
/**
 * \brief Example class demonstrating database access in Qt.
 *
 * This class provides a simple example of how to establish a connection with a
 * database and perform basic SQL operations like reading and writing data using
 * the Qt SQL module.
 */
class DatabaseAccessExample
{
public:
    /**
     * Constructor for DatabaseAccessExample.
     *
     * Establishes a connection to a database.
     * \param dbName The name of the database to connect to.
     */
    DatabaseAccessExample(const QString &dbName)
    {
        db = QSqlDatabase::addDatabase("QSQLITE");
        db.setDatabaseName(dbName);
        if (!db.open())
        {
            qWarning() << "Error: connection with database failed: " << db.lastError();
        }
        else
        {
            qDebug() << "Database: connection ok";
        }
    }
    ~DatabaseAccessExample()
    {
        db.close();
    }
    /**
     * Executes a SQL query to retrieve data from the database.
     *
     * \param queryStr The SQL query string to execute.
     * \return True if the query was successful, false otherwise.
     */
    bool executeQuery(const QString &queryStr)
    {
        QSqlQuery query;
        if (!query.exec(queryStr))
        {
            qWarning() << "Failed to execute query: " << query.lastError();
            return false;
        }
        while (query.next())
        {
            QString data = query.value(0).toString();
            qDebug() << data;
        }
        return true;
    }
    /**
     * Inserts data into the database.
     *
     * \param tableName The name of the table to insert data into.
     * \param data The data to insert.
     * \return True if the insertion was successful, false otherwise.
     */
    bool insertData(const QString &tableName, const QVariantMap &data)
    {
        QSqlQuery query;
        QString queryString = QString("INSERT INTO %1 (").arg(tableName);
        QStringList fields, values;
        for (auto it = data.constBegin(); it != data.constEnd(); ++it)
        {
            fields << it.key();
            values << ":" + it.key();
        }
        queryString += fields.join(", ") + ") VALUES (" + values.join(", ") + ")";
        query.prepare(queryString);
        for (auto it = data.constBegin(); it != data.constEnd(); ++it)
        {
            query.bindValue(":" + it.key(), it.value());
        }
        if (!query.exec())
        {
            qWarning() << "Failed to insert data: " << query.lastError();
            return false;
        }
        return true;
    }
private:
    QSqlDatabase db; ///< Database connection object.
};

#include <QtConcurrent/QtConcurrent>
#include <QFuture>
#include <QFutureWatcher>
#include <QObject>
#include <QDebug>
/**
 * \brief Example class demonstrating the use of QtConcurrent, QFuture, and QFutureWatcher.
 *
 * This class provides an example of how to run time-consuming tasks in a separate
 * thread using QtConcurrent, and monitor their progress and completion with
 * QFuture and QFutureWatcher. It's ideal for tasks that don't need to interact
 * with GUI elements directly.
 */
class ConcurrentTaskExample : public QObject
{
    Q_OBJECT
public:
    ConcurrentTaskExample() 
    {
        // Connect the signals from the QFutureWatcher
        connect(&watcher, &QFutureWatcher<void>::finished, this, &ConcurrentTaskExample::onTaskCompleted);
    }
    /**
     * Starts a time-consuming task in a separate thread.
     */
    void startTask()
    {
        // QFuture to hold the result of the task
        QFuture<void> future = QtConcurrent::run(this, &ConcurrentTaskExample::longRunningTask);
        
        // Start watching the future
        watcher.setFuture(future);
    }
private:
    QFutureWatcher<void> watcher; ///< Watches for the completion of the long-running task
    /**
     * Represents a long-running task.
     */
    void longRunningTask()
    {
        // Perform a time-consuming operation
        qDebug() << "Task started";
        QThread::sleep(5); // Simulate a long task
        qDebug() << "Task completed";
    }
public slots:
    /**
     * Slot to handle the completion of the long-running task.
     */
    void onTaskCompleted()
    {
        qDebug() << "Task is completed";
        // Handle the completion of the task, e.g., update the UI
    }
};

QWidget *parent = new QWidget;
QPushButton *button = new QPushButton(parent);
// 当 parent 被销毁时，button 也会被销毁

#include <QWidget>
#include <QPushButton>
/**
 * \brief Example class that demonstrates manual memory management in Qt.
 * 
 * This class is a simple demonstration of how a developer can manually manage
 * the lifecycle of Qt objects, specifically QWidgets. It shows the creation
 * and destruction of a QPushButton.
 */
class ManualMemoryManagementExample
{
public:
    ManualMemoryManagementExample() 
    {
        // 构造函数中创建 QPushButton
        button = new QPushButton("Click me");
        // 配置 QPushButton 的属性或信号/槽
        button->setGeometry(100, 100, 80, 30);
        // 其他配置...
    }
    ~ManualMemoryManagementExample()
    {
        // 析构函数中删除 QPushButton
        delete button;
    }
    // 显示按钮的方法
    void showButton() 
    {
        button->show();
    }
private:
    QPushButton *button; ///< 指向 QPushButton 的指针
};