qt5学习（一）

﹏ヽ暗。殇╰゛Y 2022-03-17 00:40 201阅读 0赞

Qt 是一个著名的 C++ 应用程序框架。你并不能说它只是一个 GUI 库，因为 Qt 十分庞大，并不仅仅是 GUI 组  
件。使用 Qt，在一定程度上你获得的是一个“一站式”的解决方案：不再需要研究 STL，不再需要 C++ 的，  
不再需要到处去找解析 XML、连接数据库、访问网络的各种第三方库，因为 Qt 自己内置了这些技术。

Qt Creator 帮助我们在项目文件夹下生成了四个文件：main.cpp，mainwindow.cpp，mainwindow.h 和 [HelloWorld.pro][]。pro 文件就是 Qt 工程文件（project file），由 qmake 处理，生成 make 程序所需要的 makefile；main.cpp 里面就是一个main函数，作为应用程序的入口函数；其他两个文件就是先前我们曾经指定的文件名的文件。

#include <QApplication>  //GUI 程序是 QApplication，非 GUI 程序是 QCoreApplication,QApplication 实际上是 QCoreApplication 的子类
    #include <QLabel>  // QLabel 用来显示文本，QLabel 继承自 QWidget
     
    int main(int argc, char *argv[])
    {
        QApplication app(argc, argv);
     
        QLabel label("Hello, world");
        label.show();
     
        return app.exec();  // 调用 app.exec()，开启事件循环,这样窗口可以一直保存。
    }

1，信号槽是 Qt 框架引以为豪的机制之一， 所谓信号槽，实际就是观察者模式。当某个事件发生之后，比如，按钮检测到自己被点击了一下，它就会发出一个信号（signal）。这种发出是没有目的的，类似广播。如果有对象对这个信号感兴趣，它就会使用连接（connect）函数，意思是，用自己的一个函数（称为槽（slot））来处理这个信号。也就是说，当信号发出时，被连接的槽函数会自动被回调。这就类似观察者模式：当发生了感兴趣的事件，某一个操作就会被自动触发。（这里提一句，Qt 的信号槽使用了额外的处理来实现，并不是 GoF 经典的观察者模式的实现方式。） ,信号槽机制的实现在QObject中。

#include <QApplication>
    #include <QPushButton>
     
    int main(int argc, char *argv[])
    {
        QApplication app(argc, argv);
     
        QPushButton button("Quit");
        QObject::connect(&button, &QPushButton::clicked, &QApplication::quit);
        button.show();
     
        return app.exec();
    }

2，connect函数学习：信号槽机制，用于解决对象之间的通讯  
经典的观察者模式在讲解举例的时候通常会举报纸和订阅者的例子。有一个报纸类 Newspaper，有一个订阅者类 Subscriber。Subscriber 可以订阅 Newspaper。这样，当 Newspaper 有了新的内容的时候，Subscriber 可以立即得到通知。

#include <QObject>
    // newspaper.h
    class Newspaper : public QObject
    {
        Q_OBJECT //使用信号和槽的时候才需要加上
    public:
        Newspaper(const QString & name) :
            m_name(name)
        {
        }
    
        void send()
        {
            emit newPaper(m_name); //，emit是一个关键字，表示发出，也就是发出 newPaper() 信号
        }
    
    signals:
        void newPaper(const QString &name);
    
    private:
        QString m_name;
    };
    
    // reader.h
    #include <QObject>
    #include <QDebug>  //打印
    
    class Reader : public QObject
    {
        Q_OBJECT
    public:
        Reader() {}
    
        void receiveNewspaper(const QString & name)
        {
            qDebug() << "Receives Newspaper: " << name;
        }
    };
    
    // main.cpp
    #include <QCoreApplication>
    #include "newspaper.h"
    #include "reader.h"
    
    int main(int argc, char *argv[])
    {
        QCoreApplication app(argc, argv);  //没有用到QGUI
    
        Newspaper newspaper("Newspaper A");
        Reader reader;
        QObject::connect(&newspaper, &Newspaper::newPaper,
                         &reader,    &Reader::receiveNewspaper);
        newspaper.send();
    
        return app.exec();
    }

3，QMainWindow 是 Qt 框架带来的一个预定义好的主窗口类

#include <QApplication>
        #include "mainwindow.h"
        
        int main(int argc, char* argv[])
        {
            QApplication app;
    
            MainWindow win; //定义一个主窗口类
            win.show();
    
            return app.exec();
        }

在qt5中Qt 4 中没有 widgets 模块，因此在 pro 文件中加上  
greaterThan(QT\_MAJOR\_VERSION, 4): QT += widgets

主窗口，通常是由一个标题栏，一个菜单栏，若干工具栏和一个任务栏。在这些子组件之间则是我们的工作区。主窗口的最上面是 Window Title，也就是标题栏,通常用于显示标题和控制按钮，比如最大化、最小化和关闭等.Window Title 下面是 Menu Bar，也就是菜单栏，用于显示菜单。窗口最底部是 Status Bar，称为状态栏.最外层称为 Tool Bar Area，用于显示工具条区域。

// ========== mainwindow.h
    #ifndef MAINWINDOW_H
    #define MAINWINDOW_H
    
    #include <QMainWindow>
    
    class MainWindow : public QMainWindow
    {
        Q_OBJECT
    public:
        MainWindow(QWidget *parent = 0);
        ~MainWindow();
    
    private:
        void open();
    
        QAction *openAction;
    };
    
    #endif
    
    // ========== mainwindow.cpp
    Qt 使用 QAction 类作为动作，QAction 包含了图标、菜单文字、快捷键、状态栏文字、浮动帮助等信息，
    #include <QAction>
    #include <QMenuBar>
    #include <QMessageBox>
    #include <QStatusBar>
    #include <QToolBar>
    
    #include "mainwindow.h"
    
    MainWindow::MainWindow(QWidget *parent) :
        QMainWindow(parent)
    {
        setWindowTitle(tr("Main Window")); //setWindowTitle()，设置主窗口的标题, tr() 函数是一个用于 Qt 国际化的函数,，基于上下文的字符串翻译机制（国际化），也就是 tr() 函数
        openAction = new QAction(QIcon(":/images/doc-open"), tr("&Open..."), this); //QIcon 加载了一张 png 图片或设置图标
        openAction->setShortcuts(QKeySequence::Open);  //用于说明这个 QAction 的快捷键
        openAction->setStatusTip(tr("Open an existing file"));  //setStatusTip() 则实现了当用户鼠标滑过这个 action 时，会在主窗口下方的状态栏显示相应的提示
        connect(openAction, &QAction::triggered, this, &MainWindow::open); //绑定
         //Qt 为我们创建了一个菜单栏
        QMenu *file = menuBar()->addMenu(tr("&File")); 。//addMenu() 函数为其添加菜单中
        file->addAction(openAction);   创建菜单栏并添加到动作中
    
        QToolBar *toolBar = addToolBar(tr("&File"));//addToolBar() 函数添加新的工具栏
        toolBar->addAction(openAction);//创建工具栏并添加到动作中。
        
        statusBar() ;
    }
    
    MainWindow::~MainWindow()
    {
    }
    
    //Qt 中使用 QDialog 类实现对话框
     void MainWindow::open()
    {
            QDialog *dialog = new QDialog;
            dialog->setAttribute(Qt::WA_DeleteOnClose); //setAttribute() 函数设置对话框关闭时，自动销毁对话框,解决了对象的删除问题。
            dialog->setWindowTitle(tr("Hello, dialog!"));
            dialog->show();
    }

void MainWindow::open()
    {
        QMessageBox::information(this, tr("Information"), tr("Open"));  
    }
    
    / main.cpp
        int main(int argc, char *argv[])
        {
            QApplication app(argc, argv);
    
            MainWindow win;
            win.show();
    
            return app.exec();
        }

4, QSpinBox 就是只能输入数字的输入框，并且带有上下箭头的步进按钮。QSlider 则是带有滑块的滑竿。  
Qt 提供了几种布局管理器供我们选择：  
QHBoxLayout：按照水平方向从左到右布局；  
QVBoxLayout：按照竖直方向从上到下布局；  
QGridLayout：在一个网格中进行布局，类似于 HTML 的 table；  
QFormLayout：按照表格布局，每一行前面是一段文本，文本后面跟随一个组件（通常是输入框），类似 HTML 的 form；  
QStackedLayout：层叠的布局，允许我们将几个组件按照 Z 轴方向堆叠，可以形成向导那种一页一页的效果

int main(int argc, char *argv[])
    {
        QApplication app(argc, argv);
    
        QWidget window;
        window.setWindowTitle("Enter your age");
    
        QSpinBox *spinBox = new QSpinBox(&window);
        QSlider *slider = new QSlider(Qt::Horizontal, &window);
        spinBox->setRange(0, 130); //setRange() 函数设置其范围
        slider->setRange(0, 130);
        //将 slider 的 valueChanged() 信号同 spinBox 的 setValue() 函数相连
        QObject::connect(slider, &QSlider::valueChanged, spinBox, &QSpinBox::setValue); 
    //QSpinBox 有两个信号：void valueChanged(int)和 void valueChanged(const QString &)属于重载，因此我们需要用函数指针来区别他们。
        void (QSpinBox:: *spinBoxSignal)(int) = &QSpinBox::valueChanged;
        QObject::connect(spinBox, spinBoxSignal, slider, &QSlider::setValue);
        spinBox->setValue(35);
        //按照水平方向从左到右布局
        QHBoxLayout *layout = new QHBoxLayout;
        layout->addWidget(spinBox);
        layout->addWidget(slider);
        window.setLayout(layout);
    
        window.show();
    
        return app.exec();
    }

5,对话框学习：  
对话框类型:  
QColorDialog：选择颜色；  
QFileDialog：选择文件或者目录；  
QFontDialog：选择字体；  
QInputDialog：允许用户输入一个值，并将其值返回；  
QMessageBox：模态对话框，用于显示信息、询问问题等；  
QPageSetupDialog：为打印机提供纸张相关的选项；  
QPrintDialog：打印机配置；  
QPrintPreviewDialog：打印预览；  
QProgressDialog：显示操作过程。

void MainWindow::open()
    {
            QDialog dialog(this);
            dialog.setWindowTitle(tr("Hello, dialog!"));
            dialog.exec();  //exec() 开始了一个事件循环，代码被阻塞到这里,下面的语句不会执行了
            qDebug() << dialog.result();  //   qDebug() 类似于 std::cout
    }
    
    实际上，QDialog::exec() 是有返回值的，其返回值是 QDialog::Accepted 或者 QDialog::Rejected。一般我们会使用类似下面的代码：
         QDialog dialog(this);
        if (dialog.exec() == QDialog::Accepted) {
            // do something
        } else {
            // do something else
        }
    上面代码可以判断对话框的返回值，也就是用户是点击了“确定”还是“取消”。
    
    void UserAgeDialog::accept()
    {
        emit userAgeChanged(newAge); // newAge is an int
        QDialog::accept();
    }
    
    // in main window:
    void MainWindow::showUserAgeDialog()
    {
        UserAgeDialog *dialog = new UserAgeDialog(this);
        connect(dialog, &UserAgeDialog::userAgeChanged, this, &MainWindow::setUserAge);
        dialog->show();
    }
    
    // ...
    
    void MainWindow::setUserAge(int age)
    {
        userAge = age;
    }

5，QMessageBox 用于显示消息提示

制作一个询问是否保存的对话框

QMessageBox msgBox;   //建立在栈上的 QMessageBox
        msgBox.setText(tr("The document has been modified."));   //设置其标题 
        msgBox.setInformativeText(tr("Do you want to save your changes?")); //对话框中显示的文字
        msgBox.setDetailedText(tr("Differences here...")); //详细信息
        msgBox.setStandardButtons(QMessageBox::Save
                                  | QMessageBox::Discard
                                  | QMessageBox::Cancel);
        msgBox.setDefaultButton(QMessageBox::Save);
        int ret = msgBox.exec(); //使用了 exec() 是其成为一个模态对话框，根据其返回值进行相应的操作。
        switch (ret) {
        case QMessageBox::Save:
            qDebug() << "Save document!";
            break;
        case QMessageBox::Discard:
            qDebug() << "Discard changes!";
            break;
        case QMessageBox::Cancel:
            qDebug() << "Close document!";
            break;
        }

openAction = new QAction(QIcon(":/images/file-open"), tr("&Open..."), this);
        openAction->setShortcuts(QKeySequence::Open);
        openAction->setStatusTip(tr("Open an existing file"));
    
        saveAction = new QAction(QIcon(":/images/file-save"), tr("&Save..."), this);
        saveAction->setShortcuts(QKeySequence::Save);
        saveAction->setStatusTip(tr("Save a new file"));
    
        QMenu *file = menuBar()->addMenu(tr("&File"));
        file->addAction(openAction);
        file->addAction(saveAction);
    
        QToolBar *toolBar = addToolBar(tr("&File"));
        toolBar->addAction(openAction);
        toolBar->addAction(saveAction);
        
    //创建一个带有文本编辑功能:
        textEdit = new QTextEdit(this);
        setCentralWidget(textEdit);
        
    //在菜单和工具栏添加了两个动作：打开和保存。接下来是一个 QTextEdit 类，这个类用于显示富文本文件
    connect(openAction, &QAction::triggered, this, &MainWindow::openFile);
    connect(saveAction, &QAction::triggered, this, &MainWindow::saveFile);
    
    //信号和曹函数实现
        void MainWindow::openFile()
        {
               //QFileDialog::getOpenFileName() 返回值是选择的文件路径
            QString path = QFileDialog::getOpenFileName(this, tr("Open File")，   ".",   tr("Text Files(*.txt)"));
            if(!path.isEmpty()) {
                QFile file(path);
                if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
                    QMessageBox::warning(this, tr("Read File"),
                                         tr("Cannot open file:\n%1").arg(path));
                    return;
                }
                QTextStream in(&file);
                textEdit->setText(in.readAll());
                file.close();
            } else {
                QMessageBox::warning(this, tr("Path"),
                                     tr("You did not select any file."));
            }
        }
    
        void MainWindow::saveFile()
        {
            QString path = QFileDialog::getSaveFileName(this,  tr("Open File"),
                                                        ".",
                                                        tr("Text Files(*.txt)"));
            if(!path.isEmpty()) {
                QFile file(path);
                if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
                    QMessageBox::warning(this, tr("Write File"),
                                               tr("Cannot open file:\n%1").arg(path));
                    return;
                }
                QTextStream out(&file);
                out << textEdit->toPlainText();
                file.close();
            } else {
                QMessageBox::warning(this, tr("Path"),
                                     tr("You did not select any file."));
            }
        }

6,事件处理学习：  
我们设计了一堆功能放在界面上，用户点击了“打开文件”，于是开始执行打开文件的操作；用户点击了“保存文件”，于是开始执行保存文件的操作。我们不知道用户究竟想进行什么操作，因此也就不能预测接下来将会调用哪一个函数。如果我们设计了一个“文件另存为”的操作，如果用户不点击，这个操作将永远不会被调用。这就是所谓的“事件驱动”.**话句话说，所谓的“事件驱动”，就是我们的程序的执行顺序不再是线性的，而是由一个个事件驱动着程序继续执行**。在使用 Qt 组件时，我们并不会把主要精力放在事件上。因为在 Qt 中，我们关心的更多的是事件关联的一个信号  
Qt 中的事件和信号槽却并不是可以相互替代的。信号由具体的对象发出，然后会马上交给由 connect() 函数连接的槽进行处理；而对于事件，Qt 使用一个事件队列对所有发出的事件进行维护，当新的事件产生时，会被追加到事件队列的尾部。前一个事件完成后，取出后面的事件进行处理。但是，必要的时候，Qt 的事件也可以不进入事件队列，而是直接处理。信号一旦发出，对应的槽函数一定会被执行。但是，事件则可以使用“事件过滤器”进行过滤，对于有些事件进行额外的处理，另外的事件则不关心。  
在所有组件的父类 QWidget 中，定义了很多事件处理的回调函数，如 keyPressEvent()、keyReleaseEvent()、mouseDoubleClickEvent()、mouseMoveEvent ()、mousePressEvent()、mouseReleaseEvent() 等。这些函数都是 protected virtual 的，也就是说，我们可以在子类中重新实现这些函数

class EventLabel : public QLabel
        {
        protected:
            void mouseMoveEvent(QMouseEvent *event);
            void mousePressEvent(QMouseEvent *event);
            void mouseReleaseEvent(QMouseEvent *event);
        };
    
        void EventLabel::mouseMoveEvent(QMouseEvent *event)
        {
            this->setText(QString("<center><h1>Move: (%1, %2)</h1></center>")
                          .arg(QString::number(event->x()), QString::number(event->y())));
                        //语句将会使用 x 替换 %1，y 替换 %2，因此，这个语句生成的 QString 为 [x, y]
        }
    
        void EventLabel::mousePressEvent(QMouseEvent *event)
        {
            this->setText(QString("<center><h1>Press: (%1, %2)</h1></center>")
                          .arg(QString::number(event->x()), QString::number(event->y())));
        }
    
        void EventLabel::mouseReleaseEvent(QMouseEvent *event)
        {
            QString msg;
            msg.sprintf("<center><h1>Release: (%d, %d)</h1></center>",
                        event->x(), event->y());
            this->setText(msg);
        }
    
        int main(int argc, char *argv[])
        {
            QApplication a(argc, argv);
    
            EventLabel *label = new EventLabel;
            label->setWindowTitle("MouseEvent Demo");
            label->resize(300, 200);
            label->show();
    
            return a.exec();
        }

[HelloWorld.pro]: http://HelloWorld.pro