【QT】基础入门学习

浅析Qt应用程序的主函数

#include "mywindow.h"

#include <QApplication>

// 程序的入口
int main(int argc, char *argv[])
{
    // argc是命令行参数个数，argv是命令行参数
    // QApplication a(argc, argv),管理Qt程序的运行，和设置Qt应用程序，针对QWidget应用程序
    // QGuiApplication a(argc, argv),管理Qt程序的运行，和设置Qt应用程序，针对非QWidget应用程序，比如QQuick
    // QCoreApplication a(argc, argv),管理Qt程序的运行，和设置Qt应用程序，针对无界面的应用程序
    QApplication a(argc, argv);
    // MyWindow是我们自己定义的类，w是创建的对象
    MyWindow w;
    // w对象调用了show()方法
    w.show();
    // 事件循环，QEventLoop::exec()，等待鼠标或者键盘等其他的输入
    return a.exec();
}

使用qDebug()函数

如果使用qDebug()函数，要添加#include 头文件。
debug过程中比较常用的是qDebug()函数。对于Qt Creator，它是输出到应用程序输出栏。

#include "mywindow.h"
#include "ui_mywindow.h"
#include <QDebug>

MyWindow::MyWindow(QWidget *parent)
    : QMainWindow(parent)
    , i(4) // i = 4;
    , ui(new Ui::MyWindow) // ui = new Ui::MyWindow;
{
    //i = 4;
    ui->setupUi(this);
    qDebug() << "构造函数执行了！" << endl;
}

MyWindow::~MyWindow()
{
    qDebug() << "析构函数执行了！" << endl;
    delete ui;
}

常用快捷键

Qt 编码风格

Qt 编码风格

信号槽连接模型

实现方案

1. 分别定义2个类，School类和Student类。
   
2. 源文件实现
   mainwindow.cpp 实现

 #include "mainwindow.h"
#include "ui_mainwindow.h"

// 主窗口类的构造函数，接受一个 QWidget* 类型的父窗口指针
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
   , ui(new Ui::MainWindow)
{
    // 调用 setupUi 函数来设置主窗口的界面布局和用户界面元素
    ui->setupUi(this);

    // 创建一个 Student 类的对象，并将其指针存储在 student_object 变量中
    student_object = new Student;
    // 创建一个 School 类的对象，并将其指针存储在 school_object 变量中
    school_object = new School;

    // 建立信号与槽的连接，当 school_object（学校对象）发出 send_message 信号时，
    // student_object（学生对象）的 comeBackToClass 槽函数将被调用
    connect(school_object, SIGNAL(send_message()), student_object, SLOT(comeBackToClass()));

    // 手动发出 school_object 的 send_message 信号，触发与之连接的槽函数
    emit school_object->send_message();
}

// 主窗口类的析构函数
MainWindow::~MainWindow()
{
    // 释放由 setupUi 函数分配的用户界面资源
    delete ui;
}

school.cpp 实现

#include "school.h"
#include <QObject>

School::School(QObject *parent) : QObject(parent)
{
    qDebug("创建一个类型:School");
}

student.cpp 实现

#include "student.h"
#include <QDebug>

Student::Student(QObject *parent) : QObject(parent)
{
    qDebug("创建一个类型:Student");
}

void Student::comeBackToClass()
{
   qDebug("学生去上课");
}

4. 头文件实现
   以下是对这段代码添加注释后的内容：

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

// 引入 Qt 的主窗口类头文件
#include <QMainWindow>

// 引入自定义的 School 类和 Student 类的头文件
#include "school.h"
#include "student.h"

// 前向声明 School 类和 Student 类，避免循环包含头文件
class School;
class Student;

// 开始 Qt 的命名空间
QT_BEGIN_NAMESPACE
// 命名空间 Ui 中定义了图形界面生成的类
namespace Ui { class MainWindow; }
// 结束 Qt 的命名空间
QT_END_NAMESPACE

// 定义 MainWindow 类，继承自 QMainWindow
class MainWindow : public QMainWindow
{
    // 声明 Q_OBJECT 宏，用于支持 Qt 的信号与槽等特性
    Q_OBJECT

public:
    // 主窗口类的构造函数，接受一个可选的父窗口指针
    MainWindow(QWidget *parent = nullptr);
    // 主窗口类的析构函数
    ~MainWindow();

private:
    // 指向由 Qt 的图形界面设计器生成的用户界面类的指针
    Ui::MainWindow *ui;
    // 指向 Student 类对象的指针
    Student *student_object;
    // 指向 School 类对象的指针
    School *school_object;
};
#endif // MAINWINDOW_H

#ifndef SCHOOL_H
#define SCHOOL_H

// 引入 Qt 的核心类头文件
#include <QObject>

// 定义 School 类，继承自 QObject
class School : public QObject
{
    // 声明 Q_OBJECT 宏，用于支持 Qt 的信号与槽等特性
    Q_OBJECT
public:
    // School 类的构造函数，接受一个可选的父对象指针
    explicit School(QObject *parent = nullptr);

    // 信号声明部分
    signals: 
        // 声明一个名为 send_message 的信号，只声明，不用定义
        void send_message();

};

#endif // SCHOOL_H

#ifndef STUDENT_H
#define STUDENT_H

// 引入 Qt 的核心类头文件
#include <QObject>

// 定义 Student 类，继承自 QObject
class Student : public QObject
{
    // 声明 Q_OBJECT 宏，用于支持 Qt 的信号与槽等特性
    Q_OBJECT
public:
    // Student 类的构造函数，接受一个可选的父对象指针
    explicit Student(QObject *parent = nullptr);

    // 信号声明部分，这里暂未声明任何信号

public slots:
    // 声明一个名为 comeBackToClass 的槽函数
    void comeBackToClass(void);
};

#endif // STUDENT_H

最终实现效果

信号和槽的工作机制

一、信号的发出
当某个特定的事件发生在一个对象（发送者）中时，这个对象可以发出一个信号。例如，当用户点击一个按钮时，按钮对象可以发出一个 “clicked” 信号。这个信号的发出通常是通过使用emit关键字来实现的。
信号只是一个声明，它不需要实现具体的代码逻辑。信号可以携带参数，以便在发出信号时传递一些额外的信息。
二、槽的定义和连接
槽是一个普通的成员函数，可以在任何 Qt 对象中定义。槽函数可以有不同的参数和返回值类型，具体取决于需要处理的信号。例如，一个槽函数可以用来处理按钮点击事件，执行一些特定的操作，如打开一个新窗口、更新数据等。
为了建立信号与槽的连接，可以使用connect函数。这个函数接受发送者对象、发送者发出的信号、接收者对象和接收者的槽函数作为参数。例如：connect(senderObject, SIGNAL(signalName()), receiverObject, SLOT(slotName()));。这样，当发送者发出指定的信号时，接收者的槽函数就会被调用。
三、信号与槽的调用过程
当发送者发出信号时，Qt 的元对象系统会自动查找所有与这个信号连接的槽函数，并将信号携带的参数传递给槽函数。
槽函数会在接收者对象的上下文中被调用，就像普通的成员函数一样。如果有多个接收者连接到同一个信号，那么这些接收者的槽函数会按照连接的顺序依次被调用。
信号与槽的连接是动态的，可以在运行时建立和断开。这使得程序可以根据不同的情况灵活地调整对象之间的通信关系。
总之，信号与槽机制提供了一种松耦合的通信方式，使得不同的对象可以在不了解对方内部实现的情况下进行交互。这种机制使得 Qt 程序的设计更加灵活、可维护和可扩展。

QObject::connect(sender, SIGNAL(signal()), receiver, SLOT(slot()));
connect(sender, SIGNAL(signal()), receiver, SLOT(slot()));//connect() 是 QObject 类的一个静态函数，而 QObject 是所有 Qt 类的基类，在实际调用时可以忽略前面的限定符，

Qt对象树机制

Qt 的对象树机制是一种自动管理内存的机制，它可以有效地避免内存泄漏问题，同时也方便了对象的管理和组织。

假设我们要收拾桌子，我们把桌子当作父对象，桌子上面的饭菜当作是子对象，我们收拾桌子之前，肯定是先收拾饭菜，然后再收拾桌子。我们把收拾桌子比作对象析构的过程：父对象析构的时候，会先析构所有的子对象

一、机制原理

在 Qt 中，当创建一个 QObject 对象时，可以将其作为另一个 QObject 对象的子对象。例如：

 // 1.通过构造函数传参
QObject *parentObject = new QObject();
QObject *childObject = new QObject(parentObject);

 // 2.通过setParent()方法
childObject ->setParent(parentObject);

这里，childObject被设置为parentObject的子对象。当父对象被销毁时，它的所有子对象也会被自动销毁。这是因为 QObject 的析构函数会遍历其所有子对象，并依次销毁它们。

二、作用和优势

1. 内存管理：

   • 通过对象树机制，无需手动跟踪和释放每个对象的内存，大大减少了内存泄漏的风险。
   • 当一个对象不再需要时，只需销毁它的父对象，就可以自动清理其所有子对象，简化了内存管理的过程。

2. 对象组织：

   • 对象树提供了一种清晰的层次结构，方便对相关对象进行组织和管理。
   • 可以通过遍历对象树来快速访问特定的对象或执行特定的操作。

3. 信号与槽机制的便利：

   • 在对象树中，信号可以自动传播到父对象和子对象，使得事件的传递更加方便和高效。
   • 可以利用对象树的结构来设计和实现复杂的交互逻辑。

三、注意事项

1. 确保正确设置父对象：在创建对象时，务必正确设置父对象，以确保对象树的完整性。如果父对象在子对象之前被销毁，可能会导致未定义的行为。

2. 避免循环引用：虽然对象树机制可以自动管理内存，但如果存在循环引用，可能会导致内存泄漏。例如，如果两个对象相互引用对方作为父对象或子对象，那么它们将无法被正确销毁。

3. 手动删除对象：在某些情况下，可能需要手动删除对象。例如，如果一个对象不再需要，但它的父对象仍然存在，那么可以使用delete关键字手动删除该对象。但在手动删除对象时，需要注意避免破坏对象树的结构。

总之，Qt 的对象树机制是一种强大的内存管理和对象组织工具，可以提高开发效率，减少内存泄漏的风险。在使用 Qt 进行开发时，应充分利用对象树机制，并注意遵循其使用规则，以确保程序的稳定性和可靠性。