Qt基础控件

ToolButton按钮设置图标的方法

和普通的Push Button按钮不同 它设置图标需要记得勾选一个控件

否则就算设置好控件的长宽与图片的一样依旧不行，会有一个框框。

而且一定要看图片的长宽，我们这个图片的大小是58*32，就算在iconSize内设置多大也不会再有变化，同时按钮控件的范围最好也保持一致，不然会出现实际点击界面大于图片显示界面。直接使用代码设置图片也大差不差，就是指定控件，然后加一个set，比如下面这样

xxxxxxxxxx
ui->toolButton>setIcon(QIcon(":/1/3.Button_Small-Em_Gray.png"));

高度宽度就不说了，api都差不多。

scrollArea滚动区域使用QLabel标签添加图片

我们这里说说图片，控件，文字什么的都差不多，先看代码

xxxxxxxxxx
QLabel*pic=new QLabel;
    pic->setPixmap(QPixmap(":/1/2.jpg"));//标签类添加图像
    ui->scrollArea->setWidget(pic);//放入到滚动区域
    pic->setFixedWidth(1200);       //必须设置固定大小居中才能生效
    pic->setFixedHeight(1200);
    ui->scrollArea->setAlignment(Qt::AlignHCenter);//设置居中

我们为什么要设置固定大小?当然，我们设置的固定大小是图片大小。

首先为了缩放和主窗口一起 我们还得设置一个东西:在设计师模式设置整个主窗口为水平布局，scrollArea控件就会随着主窗口的变化自动收缩了。比如下面这样

scrollArea控件的大小基本等于主窗口了，我们可以用下拉或者又拉查看整个画面。

固定大小的原因在于:如若不固定，那么会自动把图片填充满整个scrollArea控件，它会认为这全部都是它的大小，水平居中也就没有意义了，因为它觉得，我都已经满了，还居中啥，也就是说，一个很小的图片，如果加入scrollArea而不设置固定大小，实际上scrollArea把图片作为一部分实际上填满了自己。

Windeployqt命令在Windows下打包Qt程序

首先要找到Qt的命令提示符

用哪种编译器就用哪个打包

1. 先让项目用release跑一遍
2. 使用命令提示符，cd到对应生成的exe路径(推荐重新创建一个文件夹再拷贝exe就行)
3. 输入windeployqt 程序名称 程序名称也就是exe后缀的

然后就会自动把对应的库，也就是dll等文件拷贝过来，就完成了

QDesktopServices&Qurl写一个浏览器搜索框

代码如下

xxxxxxxxxx
    //添加到toolBar工具栏
    QPushButton*b=new QPushButton("搜索");
    ui->toolBar->addWidget(b);//添加一个按钮搜索
    QPushButton*e=new QPushButton("清除");
    ui->toolBar->addWidget(e);//添加一个按钮清除
    QLineEdit*edit = new QLineEdit;
    ///edit->setMaximumWidth(200);//设置最大宽度为200
    edit->setFixedWidth(300);//设置固定宽度为300
    edit->setFixedHeight(25);//设置固定高度为30
    ui->toolBar->addWidget(edit);//添加一个单行搜索框
    edit->setFont(QFont( "宋体" , 10 ,  QFont::Normal) );//设置字体和大小
    edit->setPlaceholderText("你要搜索什么呢?(*^▽^*)");//设置默认显示
    edit->setMaxLength(30);//设置最大的输入字符数
    //edit->setText("666"); //类似于设置默认显示的test

   connect(b,&QPushButton::clicked,this,[=]()//进行搜索
   {
       QString value=edit->text();            //获取QLineEdit搜索框输入的值
       //QDesktopServices::openUrl(QUrl("https://www.baidu.com/s?ie=UTF-8&wd="+value));//百度
        QDesktopServices::openUrl(QUrl("https://www.bing.com/search?q="+value));//必应
   });
   connect(e,&QPushButton::clicked,this,[=]()
   {
       edit->clear();//清空文本框的内容
   });

视图如下:

这里面唯一特殊的也就是我们设置的搜索按钮触发的信号QDesktopServices::openUrl方法用于访问一个网址，参数要求是QUrl类型的

QVBoxLayout在滚动区域同时显示多个图片

xxxxxxxxxx
QVBoxLayout*vlayout=new QVBoxLayout;
    for(int i=0;i<8;i++)
    {
        QLabel*pic=new QLabel;
        //拼接字符串路径
        QString name=QString(":/1/%1").arg(i+1);
        //设置QLabel的图片
        pic->setPixma![Snipaste_2022-06-10_08-48-35](C:\Users\AMD\Desktop\Qt\图片\Snipaste_2022-06-10_08-48-35.png)p(QPixmap(name));
        //设置居中
        pic->setAlignment(Qt::AlignHCenter);
        //将已经设置好图片的标签QLabel插入到vlayout内
        vlayout->addWidget(pic);
    }
    //下面三行只是为了覆盖掉之前的设计 不需在意 我们的wg会覆盖掉之前的设计
    QWidget*wg=new QWidget;
    wg->setLayout(vlayout);
    ui->scrollArea->setWidget(wg);

成品差不多下面这样

我们可以看到有不止一张图片，下拉选项也很长，那就没问题了。

QProgressDialog&QTimer设置进度条

xxxxxxxxxx
QProgressDialog * progress=new QProgressDialog("正在拷贝数据...","取消拷贝",0,100,this);
    //初始化并显示进度条窗口 对话框的标题
    progress->setWindowTitle("请稍后");
    progress->show();
    //更新进度条
    static int value=0; //这里使用static是为了重复调用的时候value不被释放内存
    QTimer *timer=new QTimer;//构造QTimer对象
    connect(timer,&QTimer::timeout,this,[=]()//这个信号槽没什么好说的 它是用timer发射的信号
    {
        progress->setValue(value);
        value++;
        //当value > 最大值的时候
        if(value > progress->maximum())
        {
            timer->stop();//直到调用stop方法才会停止
            value=0;
            delete progress;
            delete timer;
        }
    });
    //用于点击取消后得以退出的信号槽
    connect(progress,&QProgressDialog::canceled,this,[=]()//此信号槽在点击取消按钮的时候触发
    {
     timer->stop();//退出
     value=0;
    });
    timer->start(50);//以msec毫秒的超时间隔启动或重新启动计时器。 这里也就是隔50毫秒

运行如下:

我们第三行调用的是show方法，其实也可以使用模态，例如下面这样

xxxxxxxxxx
progress->setWindowModality(Qt::WindowModal);   //使用模态

Qt::NonModal 非模态 Qt::WindowModal 模态+阻塞父窗口 Qt::ApplicationModal 模态 阻塞应用程序中的所有窗口

QColor&QBrush&QRect&QPixmap&QPainter设置颜色

xxxxxxxxxx
    QColor color = QColorDialog::getColor();
    //使用我们选择好的颜色属性创建brush对象
    QBrush brush(color);
    //使用Label控件color的宽和高创建rect对象
    QRect rect(0,0,ui->color->width(),ui->color->height());
    //设置显示大小，使用rect的宽和高
    QPixmap pix(rect.width(),rect.height());
    QPainter p(&pix);
    //填满矩形 参数为大小与颜色
    p.fillRect(rect,brush);
    //设置Label的颜色 所有的ui->color都是Label控件 我们先前添加的
    ui->color->setPixmap(pix);
    //字符串拼接 然后修改Label内容显示出来
    QString text =QString("red: %1,green: %2,blue: %3,透明度: %4")
            .arg(color.red()).arg(color.green()).arg(color.blue()).arg(color.alpha());
    ui->colorlabel->setText(text);

行代码是一个封装的调用，会显示如下这样:

我们手动选择之后就返回一个QColor对象

然后就会显示:

QtabWidget设置多个窗口与信号

代码如下:

xxxxxxxxxx
//移除tab页 也就是点击那个x就会触发 移除之前进行保存信息
    connect(ui->tabWidget,&QTabWidget::tabCloseRequested,this,[=](int index)
    {
       QWidget*wg=ui->tabWidget->widget(index);//部件
       QString title=ui->tabWidget->tabText(index);//标题
       m_widgets.enqueue(wg);
       m_names.enqueue(title);
       //移除
       ui->tabWidget->removeTab(index);
       //按钮状态设置为可用
       ui->addBtn->setEnabled(true);
    });
    //单纯的点击就会触发，比如重复点击同一个
    connect(ui->tabWidget,&QTabWidget::tabBarClicked,this,[=](int index)
    {
      qDebug()<<"我被点击了 我的的标题是:"+QString(ui->tabWidget->tabText(index));
    });
    //必须切换，也就是重复点击相同控件无法触发
    connect(ui->tabWidget,&QTabWidget::currentChanged,this,[=](int index)
    {
       qDebug()<<"我被切换了 的标题是:"+QString(ui->tabWidget->tabText(index));
    });
    //按钮 用于恢复之前删除的
    connect(ui->addBtn,&QPushButton::clicked,this,[=](){
        ui->tabWidget->addTab(m_widgets.dequeue(),m_names.dequeue());
        if(m_widgets.empty())
        {
            //设置按钮不可用
            ui->addBtn->setDisabled(true);
        }
    });

这里面的m_widgets与m_names放在类的私有成员也就是头文件处;

xxxxxxxxxx
QQueue<QWidget*>m_widgets;
QQueue<QString>m_names;

我们写了四个信号的，第一个connect的主要在于注意在删除之前先备份数据放入队列与字符串内，然后即可调用removeTab方法传入index进行删除。

第二三connect没什么好说的，正常触发。

第四个connect是一个按钮触发的信号，目的是恢复被我们删除的窗口 如下

ui->tabWidget->addTab(m_widgets.dequeue(),m_names.dequeue());

同时要判断队列是否为空，如果为空证明我们已经恢复完了，没有东西再进行创建，此时设置为不可用状态ui->addBtn->setDisabled(true);，同时第一个connect如果有删除控件，那么就代表队列被插入了数据，也就可以使用恢复，按钮自然也就要恢复ui->addBtn->setEnabled(true);

简单设置与界面如下:

QStackedWidget的简单使用

其实这个类和上面那个差不多，先看设计师模式下设置

也就是一个StackedWidget控件有两个页面，然后再主页面上还有两个按钮用于控制它们的切换:

代码如下:

xxxxxxxxxx
//设置默认显示的窗口
    ui->stackedWidget->setCurrentWidget(ui->page_2);

    connect(ui->win1,&QPushButton::clicked,this,[=]()
    {
        ui->stackedWidget->setCurrentIndex(0);
    });
    connect(ui->win2,&QPushButton::clicked,this,[=]()
    {
        ui->stackedWidget->setCurrentIndex(1);
    });

Qt多线程与网络通信

创建线程生成随机数&冒泡&快排&显示出来

我们先从第一步开始 设计师模式的控件:

我们创建了一个Generate类，如下 创建线程必须继承QThread类 同时重写run方法，它就是我们线程执行的代码

Generate.h

xxxxxxxxxx
#ifndef GENERATE_H
#define GENERATE_H

#include <QThread>
#include<QVector>

class Generate : public QThread
{
    Q_OBJECT
public:
    explicit Generate(QObject *parent = nullptr);

    void recvNum(int num);
protected:
    void run()override;
signals:
    void sendArray(QVector<int> num);
private:
    int m_num;
};

#endif // GENERATE_H

Generate.cpp

xxxxxxxxxx
#include "Generate.h"
#include<QElapsedTimer>
#include<QDebug>
Generate::Generate(QObject *parent): QThread{parent}{}

void Generate::recvNum(int num)
{
    m_num=num;
}
void Generate::run()
{
    qDebug()<<"生成随机数的线程的线程地址:"<<QThread::currentThread();
    QVector<int>list;
    QElapsedTimer time;
    for(int i=0;i<m_num;++i)
    {
        list.push_back(rand()%100000);
    }
    int milsec=time.elapsed();
    qDebug()<<"生成"<<m_num<<"个随机数总共用时:"<<milsec<<"毫秒";
    emit sendArray(list);//触发信号
}

就不放全部代码了，太麻烦 在mainWindow.h文件我们还创建了void starting(int num);信号 cpp有用代码如下

xxxxxxxxxx
    //1.创建子线程对象
    Generate*gen=new Generate;

    //这是一个自定义信号的connect 由this发出starting信号，gen对象的recvNum方法进行处理
    connect(this,&MainWindow::starting,gen,&Generate::recvNum);

    //2.启动子线程
    connect(ui->start,&QPushButton::clicked,this,[=]()
    {
        emit starting(10000);
        gen->start();
    });
    //接收子线程发送的数据
    connect(gen,&Generate::sendArray,this,[=](QVector<int>list)
    {
        for(int i=0;i<list.size();++i)
        {
            ui->randList->addItem(QString::number(list.at(i)));
        }
    });

第二行代码就使用了该信号调用recvNum来处理

进行冒泡与快排同时显示

接下来我们看看写好的冒泡类和快排类以及更改的mainWindow文件

xxxxxxxxxx
class BubbleSort:public QThread
{
    Q_OBJECT
public:
    explicit BubbleSort(QObject *parent=nullptr);
    void recvArray(QVector<int>list);
protected:
    void run()override;
signals:
    void finish(QVector<int> num);
private:
    QVector<int>m_list;
};

class QuickSort:public QThread
{
    Q_OBJECT;
public:
    explicit QuickSort(QObject*parent=nullptr);
    void recvArray(QVector<int>list);
protected:
    void run()override;
signals:
    void finish(QVector<int>list);
private:
    QVector<int>m_list;
    void quickSort(int left, int right, QVector<int>& arr);
};

下面是两个类的实现:

xxxxxxxxxx
BubbleSort::BubbleSort(QObject *parent):QThread(parent){}

void BubbleSort::recvArray(QVector<int> list)
{
    m_list=list;
}
void BubbleSort::run()
{
    qDebug()<<"冒泡排序的线程的线程地址:"<<QThread::currentThread();
    QElapsedTimer time;
    time.start();
    for(int i=0;i<m_list.size();++i)
    {
        for(int j=0;j<m_list.size()-i-1;++j)
        {
            if(m_list[j]>m_list[j+1])
            {
            std::swap(m_list[j],m_list[j+1]);
            }
        }
    }
    int milsec=time.elapsed();
    qDebug()<<"冒泡排序用时:"<<milsec<<"毫秒";
    emit finish(m_list);
}

//QucikSort类方法的实现如下

QuickSort::QuickSort(QObject *parent):QThread(parent){}

void QuickSort::recvArray(QVector<int> list)
{
    m_list=list;
}
void QuickSort::run()
{
    qDebug()<<"快速排序的线程的线程地址:"<<QThread::currentThread();
    QElapsedTimer time;
    time.start();
    quickSort(0,m_list.size()-1,m_list);
    int milsec=time.elapsed();
    qDebug()<<"快速排序用时:"<<milsec<<"毫秒";
    emit finish(m_list);
}

void QuickSort::quickSort(int left, int right, QVector<int>& arr){
    if (left >= right)
        return;
    int i=left, j=right, base = arr[left];//取最左边的数为基准数
    while (i < j){
        while (arr[j] >= base && i < j)
            j--;
        while (arr[i] <= base && i < j)
            i++;
        if (i < j) {
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[left], arr[i]);
    quickSort(left, i - 1, arr);//递归左边
    quickSort(i + 1, right, arr);//递归右边
}

mainWind修改后代码如下

xxxxxxxxxx
    //1.创建子线程对象
    Generate*gen=new Generate;
    BubbleSort*bubble=new BubbleSort;
    QuickSort*quick=new QuickSort;

    //这是一个自定义信号的connect 由this发出starting信号，gen对象的recvNum方法进行处理
    connect(this,&MainWindow::starting,gen,&Generate::recvNum);

    //2.启动子线程
    connect(ui->start,&QPushButton::clicked,this,[=]()
    {
        emit starting(10000);
        gen->start();
    });

    //下面两个connect用于调用sendArray方法的时候对冒泡类或者快排类的QVector赋值
    connect(gen,&Generate::sendArray,bubble,&BubbleSort::recvArray);
    connect(gen,&Generate::sendArray,quick,&QuickSort::recvArray);

    //接收子线程发送的数据
    connect(gen,&Generate::sendArray,this,[=](QVector<int>list)
    {
        bubble->start();
        quick->start();
        for(int i=0;i<list.size();++i)
        {
            ui->randList->addItem(QString::number(list.at(i)));
        }
    });
    connect(bubble,&BubbleSort::finish,this,[=](QVector<int>list)
    {
        for(int i=0;i<list.size();++i)
        {
            ui->bubbleList->addItem(QString::number(list.at(i)));
        }
    });
    connect(quick,&QuickSort::finish,this,[=](QVector<int>list)
    {
        for(int i=0;i<list.size();++i)
        {
            ui->quickList->addItem(QString::number(list.at(i)));
        }
    });

1. 是创建三个对象，也就是随机数，冒泡，快排；第一个connect是用来当调用starting(n)的时候会调用recvNum方法，也就是准备创建n个随机数
2. 这个connect是随机数对象创建的，点击按钮后就调用starting(10000);会触发第一个的信号 然后开启线程，创建随机数
3. 第三和第四个connect只是用于把冒号和快排对象的QVector对象赋值随机数，第五个connect也一起讲一下，为什么?看下面的代码

xxxxxxxxxx
void Generate::run()
{
    qDebug()<<"生成随机数的线程的线程地址:"<<QThread::currentThread();
    QVector<int>list;
    QElapsedTimer time;
    for(int i=0;i<m_num;++i)
    {
        list.push_back(rand()%100000);
    }
    int milsec=time.elapsed();
    qDebug()<<"生成"<<m_num<<"个随机数总共用时:"<<milsec<<"毫秒";
    emit sendArray(list);
}

不要遗忘了第一个随机数对象运行的时候最后一行代码是调用的sendArray(list);信号，也就是同时触发了3,4,5这三个connect

也就是完成了给BubbleSort与QuickSort的QVectorlist对象的赋值随机数与将随机数显示到randList中

最后两个connect使用的是各自自己类的finish信号，我们就举一个快排类的例子,冒泡也大差不差

xxxxxxxxxx
void QuickSort::run()
{
    qDebug()<<"快速排序的线程的线程地址:"<<QThread::currentThread();
    QElapsedTimer time;
    time.start();
    quickSort(0,m_list.size()-1,m_list);
    int milsec=time.elapsed();
    qDebug()<<"快速排序用时:"<<milsec<<"毫秒";
    emit finish(m_list);
}

这个也是在run方法，也就是线程开启的时候执行的代码，进行排序，计时，然后将排序好的QVector传入信号finish；

也就会触发在mainWindow的connect，执行函数将排序好的数字显示到对应的文本框。冒泡同理，不再强调

运行结果如下:

这种方式只适合单个任务，如果处理多个任务推荐使用下面这种

使用第二种方式创建线程

首先要创建一个任务类，必须要添加一个任务函数，叫什么无所谓，可以自由的传递参数。想要往外传递数据还是使用信号

任务函数的功能就是线程开启执行的代码，类似于第一种线程方式的run()，不过它是重写父类的方法，所以不能传参数

我们的任务对象必须继承QObject对象，因为在QObject内有一个方法叫moveToThread用于将任务对象移动到对应的子线程

修改的代码如下，三个类:

xxxxxxxxxx
class Generate : public QObject
{
    Q_OBJECT
public:
    explicit Generate(QObject *parent = nullptr);
    void working(int num);
signals:
    void sendArray(QVector<int> num);
};

class BubbleSort:public QObject
{
    Q_OBJECT
public:
    explicit BubbleSort(QObject *parent=nullptr);
    void working(QVector<int>list);
signals:
    void finish(QVector<int> num);
};

class QuickSort:public QObject
{
    Q_OBJECT;
public:
    explicit QuickSort(QObject*parent=nullptr);
    void working(QVector<int>list);
private:
    void quickSort(int left, int right, QVector<int>& arr);
signals:
    void finish(QVector<int>list);
};

这里主要的改变在于继承从QThread变成QObject，且把run方法换成了working任务函数，它能够传参，同时也就去除了三个类的私有成员,以及recvArray方法。信号不变，看cpp实现代码如下:

xxxxxxxxxx
Generate::Generate(QObject *parent): QObject{parent}{}

void Generate::working(int num)
{
    qDebug()<<"生成随机数的线程的线程地址:"<<QThread::currentThread();
    QVector<int>list;
    QElapsedTimer time;
    time.start();
    for(int i=0;i<num;++i)
    {
        list.push_back(rand()%100000);
    }
    int milsec=time.elapsed();
    qDebug()<<"生成"<<num<<"个随机数总共用时:"<<milsec<<"毫秒";
    emit sendArray(list);
}

BubbleSort::BubbleSort(QObject *parent):QObject(parent){}

void BubbleSort::working(QVector<int>list)
{
    qDebug()<<"冒泡排序的线程的线程地址:"<<QThread::currentThread();
    QElapsedTimer time;
    time.start();
    for(int i=0;i<list.size();++i)
    {
        for(int j=0;j<list.size()-i-1;++j)
        {
            if(list[j]>list[j+1])
            {
            std::swap(list[j],list[j+1]);
            }
        }
    }
    int milsec=time.elapsed();
    qDebug()<<"冒泡排序用时:"<<milsec<<"毫秒";
    emit finish(list);
}
QuickSort::QuickSort(QObject *parent):QObject(parent)
{

}
void QuickSort::working(QVector<int>list)
{
    qDebug()<<"快速排序的线程的线程地址:"<<QThread::currentThread();
    QElapsedTimer time;
    time.start();
    quickSort(0,list.size()-1,list);
    int milsec=time.elapsed();
    qDebug()<<"快速排序用时:"<<milsec<<"毫秒";
    emit finish(list);
}
void QuickSort::quickSort(int left, int right, QVector<int>& arr){
    if (left >= right)
        return;
    int i=left, j=right, base = arr[left];//取最左边的数为基准数
    while (i < j){
        while (arr[j] >= base && i < j)
            j--;
        while (arr[i] <= base && i < j)
            i++;
        if (i < j) {
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[left], arr[i]);
    quickSort(left, i - 1, arr);//递归左边
    quickSort(i + 1, right, arr);//递归右边
}

除了去除了几个recvArray的实现，把私有的m_list变成传参的list以外也就没啥区别了，下面是mainWindows.cpp的主要代码

//1.创建子线程对象
    QThread*t1=new QThread;
    QThread*t2=new QThread;
    QThread*t3=new QThread;

    ///2.創建人物类的对象
    Generate*gen=new Generate;
    BubbleSort*bubble=new BubbleSort;
    QuickSort*quick=new QuickSort;

    //3.将任务对象移动到某个子线程中
    gen->moveToThread(t1);
    bubble->moveToThread(t2);
    quick->moveToThread(t3);

    //这是一个自定义信号的connect 由this发出starting信号，gen对象的recvNum方法进行处理
    connect(this,&MainWindow::starting,gen,&Generate::working);

    //2.启动子线程
    connect(ui->start,&QPushButton::clicked,this,[=]()
    {
        emit starting(10000);
        t1->start();
    });

    //下面两个connect用于调用第一个connect被触发的时候触发信号working就会传入参数到这里进行排序
    connect(gen,&Generate::sendArray,bubble,&BubbleSort::working);
    connect(gen,&Generate::sendArray,quick,&QuickSort::working);

    //接收子线程发送的数据
    connect(gen,&Generate::sendArray,this,[=](QVector<int>list)
    {
        t2->start();
        t3->start();
        for(int i=0;i<list.size();++i)
        {
            ui->randList->addItem(QString::number(list.at(i)));
        }
    });
    connect(bubble,&BubbleSort::finish,this,[=](QVector<int>list)
    {
        for(int i=0;i<list.size();++i)
        {
            ui->bubbleList->addItem(QString::number(list.at(i)));
        }
    });
    connect(quick,&QuickSort::finish,this,[=](QVector<int>list)
    {
        for(int i=0;i<list.size();++i)
        {
            ui->quickList->addItem(QString::number(list.at(i)));
        }
    });

    //当前窗口释放的时候会释放destory信号，就会执行我们下面的代码
    connect(this,&MainWindow::destroy,this,[=]()
    {
       t1->quit();//退出线程的事件循环
       t1->wait();//等待
       t1->deleteLater();//销毁线程对象

       t2->quit();
       t2->wait();
       t2->deleteLater();

       t3->quit();
       t3->wait();
       t3->deleteLater();

       gen->deleteLater();
       bubble->deleteLater();
       quick->deleteLater();
    });

步入正题了，我们首先直接创建三个线程对象，然后再创建三个类对象。它们互相对应。

我们使用线程对象的moveToThread方法将任务对象放入到线程对象中

第一二三四个connect都和第一种方法没什么区别。不过:第二个connect的开启线程是t1->start也就是说我们都是直接操控线程对象。

第一种创建线程方法在第三四个connect调用的方法是进行赋值的，run是自己线程开启的时候执行排序之类的。而我们这种方法，因为可以传参，首先省掉了私有成员的开销，也省掉了赋值成员函数的开销。当然这还不是重点，看下面

捋一捋，首先点击按钮触发staring信号，开启t1线程；staring触发后执行gen的working方法，也就是随机数，执行完working方法发时候触发sendArray信号；这个信号会触发三个信号槽，触发冒泡与快排的working方法，第三个就是开启线程，线程对象就会分别让子线程去执行冒泡与快排的working方法，同时主线程这里将随机数显示出来；然后bubble和quick的connect他们working方法会触发finish信号；也就会有2个connect执行，分别对应显示冒泡和显示快排的结果。

最后一步就是线程资源的释放:

线程对象的quick是如果线程在事件循环就退出，否则则不执行操作，wait则是等待线程结束，类似于join，deleteLater方法和之前delete没啥区别。

线程池QThreadPool

使用qt的线程池则不需要自己释放资源，线程池来维护

同时它比较智能，我们可以看出来,当随机数创建完毕后，线程空闲不会浪费，用来进行冒泡排序

快速排序则用到线程池的另一个线程精选排序

不再说那么详细了，拿一个类举例

xxxxxxxxxx
class Generate : public QObject,public QRunnable
{
    Q_OBJECT
public:
    explicit Generate(QObject *parent = nullptr);

    void recvNum(int num);

    void run()override;

signals:
    void sendArray(QVector<int> num);

private:
    int m_num;
};

我们不再继承QThread，改成QObject和QRunnable也就是线程池类；这是拿第一种创建线程方式改进的，其实没什么变化，cpp实现没什么变化。直接看mainWindow的cpp

xxxxxxxxxx
 //1.创建任务类对象
    Generate*gen=new Generate;
    BubbleSort*bubble=new BubbleSort;
    QuickSort*quick=new QuickSort;

    connect(this,&MainWindow::starting,gen,&Generate::recvNum);

    //2.启动子线程
    connect(ui->start,&QPushButton::clicked,this,[=]()
    {
        emit starting(10000);
        QThreadPool::globalInstance()->start(gen);
    });

    //下面两个connect用于调用sendArray方法的时候对冒泡类或者快排类的QVector赋值
    connect(gen,&Generate::sendArray,bubble,&BubbleSort::recvArray);
    connect(gen,&Generate::sendArray,quick,&QuickSort::recvArray);

    //接收子线程发送的数据
    connect(gen,&Generate::sendArray,this,[=](QVector<int>list)
    {
        QThreadPool::globalInstance()->start(bubble);
        QThreadPool::globalInstance()->start(quick);
        for(int i=0;i<list.size();++i)
        {
            ui->randList->addItem(QString::number(list.at(i)));
        }
    });
    connect(bubble,&BubbleSort::finish,this,[=](QVector<int>list)
    {
        for(int i=0;i<list.size();++i)
        {
            ui->bubbleList->addItem(QString::number(list.at(i)));
        }
    });
    connect(quick,&QuickSort::finish,this,[=](QVector<int>list)
    {
        for(int i=0;i<list.size();++i)
        {
            ui->quickList->addItem(QString::number(list.at(i)));
        }
    });

和第一种创建线程方式没什么区别，只是把开启线程变成了QThreadPool::globalInstance()->start(bubble);这种样子，它是调用了线程池的静态方法。因为有线程池的存在，我们不需要自己释放资源。

基础的Qt套接字通信

C++的标准库不提供套接字通信的api，只能使用平台提供的C语言的api，但是Qt框架提供了。我们写了两个项目的代码，分别是服务器端和客户端，让它们进行连接，以此简单的演示。

Qt想要使用网络编程这方面的必须子阿pro文件加上QT += network相当于引入模块

以及三个头文件

xxxxxxxxxx
#include <QTcpServer>
#include <QTcpSocket>
#include <QHostAddress>

服务器端

下面是设计师界面和属性

我们直接先看mainWindows.h的主要代码

xxxxxxxxxx
class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
private slots:
    void on_setListen_clicked();
    void on_sendMsg_clicked();
private:
    Ui::MainWindow *ui;
    QTcpServer*m_s;
    QTcpSocket*m_tcp;
    QLabel*m_status;
};

头文件没什么好说的，类的两个信号对应的是两个按钮；

QTcpServer*m_s;它的作用主要是用来监听地址和端口。当有新的 TCP 连接，会触发 newConnection() 信号，此时可以调用 nextPendingConnection() 以将挂起的连接接受为已连接的 QTcpSocket，通过该对象可以与客户端通信。

也就是可以m_tcp=m_s->nextPendingConnection();

QTcpSocket*m_tcp;主要作用在数据之间的传输操作，写入读取等。

QLabel*m_status;这个只是用来更改连接状态的图片的。主要的实现代码如下:

xxxxxxxxxx
    ui->port->setText("8889");
    setWindowTitle("服务器");
    //创建监听的服务器对象
    m_s=new QTcpServer(this);
    //在连接成功的时候被触发
    connect(m_s,&QTcpServer::newConnection,this,[=]()
    {
        m_tcp=m_s->nextPendingConnection();//实例化对象
        //在连接成功的时候设置图片
        m_status->setPixmap(QPixmap(":/done.png").scaled(30,30));
        //检测是否可以接收数据
        connect(m_tcp,&QTcpSocket::readyRead,this,[=]()
        {
            QByteArray data = m_tcp->readAll();
            ui->record->append("客户端say:"+data);
        });
        //被断开连接的时候触发此信号
        connect(m_tcp,&QTcpSocket::disconnected,this,[=]()
        {
            m_tcp->close();
            m_tcp->deleteLater();
            m_status->setPixmap(QPixmap(":/Icons_Tint Color_Black.svg").scaled(30,30));
        });
    });
    //状态栏
    m_status=new QLabel;
    m_status->setPixmap(QPixmap(":/Icons_Tint Color_Black.svg").scaled(30,30));
    ui->statusbar->addWidget(new QLabel("连接状态:"));
    ui->statusbar->addWidget(m_status);
}
void MainWindow::on_setListen_clicked()
{
    unsigned short port=ui->port->text().toUShort();
    m_s->listen(QHostAddress::Any,port);//监听指定地址和断开
    ui->setListen->setDisabled(true);//设置按钮为不可用状态
}
void MainWindow::on_sendMsg_clicked()
{
    //以纯文本的方式把数据显示出来
    QString msg=ui->msg->toPlainText();
    m_tcp->write(msg.toUtf8());
    ui->record->append("服务器say:"+msg);
}

先给端口的控件设置默认显示8889，然后设置程序的标题为服务器；创建监听的服务器对象，也就是给成员指针new赋值，我们指定了this作为父对象，那么则不需要delete了，在释放资源的时候，Qt框架会自动为我们释放。

第一个信号槽，需要newConnection触发，其实我们已经介绍过了:当有新的 TCP 连接，会触发 newConnection() 信号

我们先看按钮，第一个按钮是监视，点击它就会读取我们的port控件里面的数据，转换为short保存，然后m_s调用 listen() 监听指定的地址和端口。然后把按钮设置为不可用状态，因为点击了就不能再点击了。

我们看状态栏，它其实就是设置左下角的状态的先new一个Label，然后m_status再加一个图片。它就完成了。然后给我们的控件加上文字描述，然后再加一个m_status也就是加一个图片，也就是设置默认状态，默认的图片。

知道这些之后我们就可以假设监视的按钮被点击后，如果有新的tcp连接，就会触发第一个信号槽:我们给m_tcp实例化。同时设置 m_status的图片为另一个，也就是一个勾勾，默认是叉叉。因为我们的statusbar控件已经被添加为m_status，所以修改它就相当于修改了m_status显示的图片。

里面还嵌套了connect，第一个的信号是QTcpSocket::readyRead，当有新的数据到来，会触发 readyRead() 信号，此时在槽函数中进行读取即可。QByteArray data = m_tcp->readAll();。readAll函数会读取全部的缓冲区数据，data进行接收，然后ui->record->append("客户端say:"+data);也就是把得到的数据全部放到record控件内，即历史记录。

嵌套的第二个connect就很简单了，如果被断开就触发信号:close 关闭套接字的 IO，以及套接字的连接；然后调用的deleteLater();和直接delete没什么区别。最后把图片设置为叉叉就行。

客户端

接下来我们写客户端：设计师模式如下

强调一下，为什么服务器端只有端口没有ip?因为服务器是在我们主机上，服务器所在的主机有ip，客户端的ip是为了连接我们的服务器的ip。端口是一个网络设备的接口，独占一个，端口作为服务器响应接收的端口。

我们放的代码不放不重要的....

好，我们看h代码

xxxxxxxxxx
class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
private slots:
    void on_sendMsg_clicked();
    void on_connect_clicked();
    void on_disconnect_clicked();
private:
    Ui::MainWindow *ui;
    QTcpSocket*m_tcp;
    QLabel*m_status;
};

三个信号对应三个按钮。QTcpSocketm_tcp;的作用和前面服务器端一样，QLabelm_status;还是改变状态的图片。cpp主要如下

xxxxxxxxxx
{
    ui->port->setText("8889");
    ui->ip->setText("192.168.182.1");
    setWindowTitle("客户端");
    ui->disconnect->setDisabled(true);

    m_tcp=new QTcpSocket;
    connect(m_tcp,&QTcpSocket::readyRead,this,[=]()
    {
        QByteArray data=m_tcp->readAll();
        ui->record->append("服务器say:"+data);
    });
 
    connect(m_tcp,&QTcpSocket::disconnected,this,[=]()
    {
        m_tcp->close();
        m_tcp->deleteLater();
        m_status->setPixmap(QPixmap(":/Icons_Tint Color_Black.svg").scaled(30,30));
        ui->record->append("服务器已经和客户端断开了...");
        ui->connect->setDisabled(false);
        ui->disconnect->setEnabled(false);
    });
    connect(m_tcp,&QTcpSocket::connected,this,[=]()
    {
        m_status->setPixmap(QPixmap(":/done.png").scaled(30,30));
        ui->record->append("已经成功连接到了服务器...");
        ui->connect->setDisabled(true);
        ui->disconnect->setEnabled(true);
    });
    //状态栏
    m_status=new QLabel;
    m_status->setPixmap(QPixmap(":/Icons_Tint Color_Black.svg").scaled(30,30));
    ui->statusbar->addWidget(new QLabel("连接状态:"));
    ui->statusbar->addWidget(m_status);
}
void MainWindow::on_sendMsg_clicked()
{
    //以纯文本的方式把数据显示出来
    QString msg=ui->msg->toPlainText();
    m_tcp->write(msg.toUtf8());
    ui->record->append("客户端say:"+msg);
}
void MainWindow::on_connect_clicked()
{
    QString ip=ui->ip->text();
    unsigned short port=ui->port->text().toUShort();
    m_tcp->connectToHost(QHostAddress(ip),port);
}
void MainWindow::on_disconnect_clicked()
{
    m_tcp->close();
    ui->connect->setDisabled(false);
    ui->disconnect->setEnabled(false);
}

前面四行还是先分别设置默认的端口，ip，然后设置程序的标题，再设置按钮为不可用，这个按钮是用于断开连接，我们会在点击连接成功后设置为可用。

先看按钮，从connect按钮开始，也就是连接，先读取到ip，然后读取到port端口，然后使用connectToHost方法进行连接，传入ip和端口作为参数，这里进行了一个匿名构造QHostAddress(ip)，它只能接收这种参数。连接到服务器端后就完成了。

不过这只是一个执行，不代表会连接成功，我们需要看第三个connect，如果触发了connected信号就代表连接成功，然后设置图片以及按钮状态。

如果点击第一个按钮那么就是把msg控件的数据发送出去，同时显示到record控件作为历史记录。

第一个connect信号槽是用来接收服务器端发送的数据，显示出来，然后剩下一个按钮和一个connect用作关闭的。状态栏和服务器一样。

上一个有一些没说清楚，readyRead信号是有新的数据到来会被触发

结果如下，懒得做美化:

多线程搭建发送文件的客户端与服务端

我们分为两个项目，先客户端，后服务器端

头文件需要如下:

xxxxxxxxxx
#include<QThread>
#include<QMessageBox>
#include<QFileDialog>
#include<QHostAddress>
#include<QFile>
#include<QFileInfo>
#include <QObject>
#include<QTcpSocket>
#include <QMainWindow>
#include<qDebug>

注意pro文件QT += core gui network

客户端

先看设计师模式与属性

我们创建了一个sendfile的类，先看头文件重要的如下:

xxxxxxxxxx
class SendFile : public QObject
{
    Q_OBJECT
public:
    explicit SendFile(QObject *parent = nullptr);
    //连接服务器
    void connectServer(unsigned short port,QString ip);
    //发送文件
    void sendFile(QString path);
signals:
    void connectOK();
    void gameover();
    void curPercent(int num);
private:
    QTcpSocket*m_tcp;
};

这个类是工作类，工作对象的函数会在线程里面执行。我们看到它有两个函数，分别表示连接和传输文件这两个功能。三个信号都是用于处理按钮信号要做的东西，在mainWindow的三个按钮不会完成全部的工作，会触发我们的信号，让工作类的方法在子线程里面运行。cpp实现两个方法如下:

xxxxxxxxxx
void SendFile::connectServer(unsigned short port, QString ip)
{
    qDebug()<<"连接服务器的线程:"<<QThread::currentThread();
    m_tcp=new QTcpSocket;
    m_tcp->connectToHost(QHostAddress(ip),port);
    //在调用connectToHost () 并成功建立连接后发出此信号 然后触发connectOK自定义信号
    connect(m_tcp,&QTcpSocket::connected,this,&SendFile::connectOK);
    //关闭的时候触发此信号进行回收资源和关闭连接，同时触发另一个connect进行线程回收和断开连接
    connect(m_tcp,&QTcpSocket::disconnected,this,[=]()
    {
        m_tcp->close();
        m_tcp->deleteLater();
        emit gameover();
    });
}
void SendFile::sendFile(QString path)
{
    qDebug()<<"发送文件的子线程:"<<QThread::currentThread();
    QFile file(path);
    QFileInfo info(path);
    int fileSize=info.size();
    file.open(QFile::ReadOnly);

    while(!file.atEnd())
    {
        static int num=0;
        if(num==0)
        {
            //告诉服务器总共要发送多少数据
            m_tcp->write((char*)&fileSize,4);
        }
        QByteArray line=file.readLine();
        num+=line.size();
        int percent=(num*100/fileSize);
        emit curPercent(percent);//更新进度条的信号
        //发送给服务器
        m_tcp->write(line);
    }
}

看mainWindow的h主要文件

xxxxxxxxxx
class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
signals:
    void startConnect(unsigned short,QString);
    void sendFile(QString path);
private slots:
    void on_connectServer_clicked();
    void on_sendFile_clicked();
    void on_selFile_clicked();
private:
    Ui::MainWindow *ui;
};

这两个信号是用于在点击按钮的时候触发这两个信号，然后connect执行的就是工作类的方法。三个槽函数对应的三个按钮。先看cpp实现如下:

xxxxxxxxxx
{
    qDebug()<<"主线程:"<<QThread::currentThread();
    ui->setupUi(this);
    ui->ip->setText("192.168.182.1");
    ui->port->setText("8989");
    ui->progressBar->setRange(0,100);//进度条范围
    ui->progressBar->setValue(0);//进度条从0开始
    //创建线程对象
    QThread*t=new QThread;
    //创建任务对象
    SendFile*worker=new SendFile;
    worker->moveToThread(t);
    connect(this,&MainWindow::sendFile,worker,&SendFile::sendFile);
    connect(this,&MainWindow::startConnect,worker,&SendFile::connectServer);
    //处理主线程发送的信号
    connect(worker,&SendFile::connectOK,this,[=]()
    {
        QMessageBox::information(this,"连接服务器","已经成功连接了服务器，恭喜!");
    });
    connect(worker,&SendFile::gameover,this,[=]()
    {
        t->quit();
        t->wait();
        worker->deleteLater();
        t->deleteLater();
    });
    connect(worker,&SendFile::curPercent,ui->progressBar,&QProgressBar::setValue);
    t->start();
}
//连接服务器按钮
void MainWindow::on_connectServer_clicked()
{
    QString ip=ui->ip->text();
    unsigned short port=ui->port->text().toUShort();
    emit startConnect(port,ip);//触发信号，在27行调用connectServer函数连接服务器的代码，在子线程运行
}
//选择文件按钮
void MainWindow::on_selFile_clicked()
{
    QString path=QFileDialog::getOpenFileName();
    if(path.isEmpty())
    {
        QMessageBox::warning(this,"打开文件","选择的文件路径不能为空!");
        return;
    }
    ui->filePath->setText(path);
}
//发送文件按钮
void MainWindow::on_sendFile_clicked()
{
    emit sendFile(ui->filePath->text());
}

前面六行是一些基础默认设置；创建线程对象，然后实例化任务对象，调用moveToThread方法，这个任务对象就被放到线程里面了，有信号触发执行它的方法就会放到线程里面执行。这两个connect信号槽是当连接服务的按钮和发送文件的按钮被点击后会触发信号，然后在子线程执行任务对象的方法。选择文件的按钮是在主线程执行，任务类也没写它的方法。

然后第三个connect的信号是在任务类的连接函数里面，如果连接成功，任务类就会触发此信号，然后主线程就执行一个弹窗。

第四个connect的信号是在任务类的连接函数里面如果断开连接的时候就会发射此信号，主线程就会执行这些关闭资源的操作。

第五个connect是百分比的信号，显示那个控件的，它的信号是在任务类的传输文件的方法进行触发。

最后线程开启，当然肯定不是执行完才开启线程的，我们是先说完了信号槽这些一个一个的，实际上是在构造的时候就开启线程，等待信号被触发的。

服务器端

服务器端很简单，先看设计师模式

我们用的是继承QThread的方式，重写run方法创建线程，我们创建了一个recvfile的类，头文件主要如下:

xxxxxxxxxx
class RecvFile : public QThread
{
    Q_OBJECT
public:
    explicit RecvFile(QTcpSocket*tcp,QObject *parent = nullptr);
protected:
    void run()override;
private:
        QTcpSocket*m_tcp;
signals:
    void over();
};

很简单，生命重写run方法，还有一个QTcpSocket*m_tcp;成员，套接字通信。还有一个over信号用来在run函数内已经接收玩数据后触发

cpp实现如下:

xxxxxxxxxx
RecvFile::RecvFile(QTcpSocket*tcp,QObject *parent): QThread{parent}
{
    m_tcp=tcp;
}
void RecvFile::run()
{
    qDebug()<<"服务器子线程:"<<QThread::currentThread();
    QFile*file =new QFile("recv.txt");
    file->open(QFile::WriteOnly);
    //接收数据
    connect(m_tcp,&QTcpSocket::readyRead,this,[=]()
    {
       static int count=0;
       static int total=0;
       if(count==0)
       {
           m_tcp->read((char*)&total,4);//读取大小
       }
       //读取剩余的数据
       QByteArray all=m_tcp->readAll();
       count+=all.size();
       file->write(all);
       //判断数据是否接收完毕了
       if(count==total)
       {
           m_tcp->close();
           m_tcp->deleteLater();
           file->close();
           file->deleteLater();
           emit over();
       }
    });
    //进入事件循环
    exec();
}

构造函数是有参构造，用于初始化私有成员。

run方法的m_tcp->read((char*)&total,4);会读取总共数据有多少字节，m_tcp->readAll();会一次性读取全部的数据；然后count+=all.size();

count得到被读取的数据的大小，然后进行比较，如果相等就证明数据读取完毕if(count==total)。然后会关闭资源和触发over信号

看mainWindow的头文件主要:

xxxxxxxxxx
class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
private slots:
    void on_setListen_clicked();
private:
    Ui::MainWindow *ui;
    QTcpServer*m_s;
};

很简单，只有一个按钮槽函数和一个私有的QTcpServer*m_s;成员用于监视是是否有客户端连接，cpp实现如下

xxxxxxxxxx
{
    ui->setupUi(this);

    qDebug()<<"服务器主线程:"<<QThread::currentThread();

    m_s=new QTcpServer(this);

    connect(m_s,&QTcpServer::newConnection,this,[=]()
    {
        QTcpSocket*tcp=m_s->nextPendingConnection();
        //创建子线程
        RecvFile*subThread=new RecvFile(tcp);
        subThread->start();

        connect(subThread,&RecvFile::over,this,[=]()
        {
            subThread->exit();
            subThread->wait();
            subThread->deleteLater();
            QMessageBox::information(this,"文件接收","文件接收完毕!");
        });
    });
}
void MainWindow::on_setListen_clicked()
{
    unsigned short port = ui->port->text().toShort();
    m_s->listen(QHostAddress::Any,port);
}

先看按钮吧，就是点击之后，会获取我们输入文本框的数据，转换为short。然后调用listen方法进行监视此端口。

构造函数里面就是给m_s先实例化。然后信号:当有新的 TCP 连接，会触发 newConnection() 信号,其实之前已经说过了。

然后创建子线程，开启线程....开启了之后就会执行之前在run写的代码，当run执行完毕接收完全部的数据就会触发over自定义信号，我们进行退出事件循环，这里用exit和quit差不多都是退出事件循环，为什么呢?因为我们在run最后写了exec();

为什么要让它进入事件循环呢?因为不同于c++标准库等的线程，qt的线程函数需要等待，等待触发信号，如果不这样做，那么就直接执行完，线程就结束了，触发信号就没用了，必须设置一个信号用于退出。其他时候一直循环等待着其他信号被触发然后执行对应的方法。

然后就是一点回收资源和提示。最后两个成品如下:

Qt事件

众所周知 Qt 是一个基于 C++ 的框架，主要用来开发带窗口的应用程序（不带窗口的也行，但不是主流）。我们使用的基于窗口的应用程序都是基于事件，其目的主要是用来实现回调（因为只有这样程序的效率才是最高的）。所以在 Qt 框架内部为我们提供了一些列的事件处理机制，当窗口事件产生之后，事件会经过：事件派发 -> 事件过滤->事件分发->事件处理几个阶段。Qt 窗口中对于产生的一系列事件都有默认的处理动作，如果我们有特殊需求就需要在合适的阶段重写事件的处理动作。

事件（event）是由系统或者 Qt 本身在不同的场景下发出的。当用户按下 / 移动鼠标、敲下键盘，或者是窗口关闭 / 大小发生变化 / 隐藏或显示都会发出一个相应的事件。一些事件在对用户操作做出响应时发出，如鼠标 / 键盘事件等；另一些事件则是由系统自动发出，如计时器事件。

每一个 Qt 应用程序都对应一个唯一的 QApplication 应用程序对象，然后调用这个对象的 exec() 函数，这样 Qt 框架内部的事件检测就开始了（程序将进入事件循环来监听应用程序的事件）。

事件处理函数的使用

事件的函数都有默认值，我们可以重写那些方法，比如QMainWindow类中的closeEvent事件处理器函数。我们可以重写如下:

xxxxxxxxxx
void MainWindow::closeEvent(QCloseEvent *ev)
{
    int ret=QMessageBox::question(this,"提问","您确定要关闭窗口吗?");
    if(ret==QMessageBox::Yes)
    {
        ev->accept();
    }
    else
    {
        ev->ignore();
    }
}

加上这段代码后，我们点击关闭按钮的时候就会弹出对话框让我们选择

如果返回值==Yes那么就执行accept函数，也就是接受的意思，反之忽略;

或者我们可以重写QResizeEvent类的resizeEvent事件处理器函数，代码如下:

xxxxxxxxxx
void MainWindow::resizeEvent(QResizeEvent *ev)
{
    qDebug()<<"oldSize:"<<ev->oldSize()<<"currSize:"<<ev->size();
}

xxxxxxxxxx
const  QSize &QResizeEvent:: oldSize () const
//返回小部件的旧尺寸。
    
const QSize&QResizeEvent:: size () const
//返回小部件的新大小。这与QWidget::size 相同。

视图如下：每次移动都会触发事件

基于事件处理器函数自定义按钮

1. 从视觉上看是一个不规则的按钮(按钮实际上都是矩形的)
2. 按钮上需要指定的背景图片
3. 按钮在鼠标的不同操作阶段(无操作，鼠标悬停，鼠标按下)能够显示不同的背景图

头文件如下:

xxxxxxxxxx
class MyButton : public QWidget
{
    Q_OBJECT
public:
    explicit MyButton(QWidget *parent = nullptr);
protected:
    void mousePressEvent(QMouseEvent*ev);
    void mouseReleaseEvent(QMouseEvent*ev);
    void enterEvent(QEvent*ev);
    void leaveEvent(QEvent*ev);
    void paintEvent(QPaintEvent*ev);
signals:
private:
    //这里两种都可以
    QPixmap m_pixmap;//专注于显示，显示的时候效率更高
    //QImage m_imag;//主要是进行跨线程的图片传输，多线程绘图，能够实现一个像素级别的修改，QPixmap不可以。
};

这里的五个函数都是重写父类的QWidget的事件处理函数，看cpp文件

xxxxxxxxxx
#include <QPainter>
//没有被任何操作的时候,也就是默认显示
MyButton::MyButton(QWidget *parent): QWidget{parent}
{
    setMouseTracking(true);
    m_pixmap.load(":/3.png");
    setFixedSize(m_pixmap.size());//设置按钮的大小和图片大小一样
}
//点击的时候
void MyButton::mousePressEvent(QMouseEvent *ev)
{
    m_pixmap.load(":/chilun.ico");
    update();//它是QWidget的槽函数会调用paintEvent重新绘制
    qDebug()<<"1";
}
//释放的时候
void MyButton::mouseReleaseEvent(QMouseEvent *ev)
{
    m_pixmap.load(":/3.png");
    update();
    qDebug()<<"2";
}
//悬停的时候
void MyButton::enterEvent(QEvent *ev)
{
    qDebug()<<"3";
//    m_pixmap.load(":/done.png");
//    update();
}
//悬停鼠标离开的时候
void MyButton::leaveEvent(QEvent *ev)
{
    m_pixmap.load(":/done.png");
    update();
    qDebug()<<"4";
}
//窗口被刷新的时候调用，比如遮盖，最小化....
void MyButton::paintEvent(QPaintEvent *ev)
{
    QPainter p(this);//指定绘图设备
    p.drawPixmap(rect(),m_pixmap);
    qDebug()<<"5";
}

那么控件如何添加?没有QWidget这个控件,其实我们可以在设计师模式添加父类的QWideget控件然后提升为MyButton即可，也就是自定义按钮了。

我们的ev都没有用到，编译器会提示警告，因为我们的确没有用到它，有两种解决方案，一种是去掉ev，只留下QPaintEvent*作为占位参数。或者使用一个Qt给我们提供的宏Q_UNUSED(ev)就是告诉编译器我的确没用到ev，你别警告了。

自定义按钮添加信号

只需要在MyButton类内加上一个void clicked();信号然后在点击的时候触发就行，如下:

xxxxxxxxxx
void MyButton::mousePressEvent(QMouseEvent *ev)
{
    m_pixmap.load(":/chilun.ico");
    update();
    emit clicked();
}

其实就是多了一个触发信号，仅此而已，然后在mainWIndow里面加上一个信号槽，如下:

xxxxxxxxxx
connect(ui->button,&MyButton::clicked,this,[=]()
    {
        QMessageBox::information(this,"按钮","物无聊无聊无聊");
    });

当按钮被点击的时候触发对话框。

事件的使用---案例

我们的目标是完成一个类似于一个透明的没有任何边框的，然后一堆蝴蝶在电脑上显示移动的画面

我们写了一个类butterfly。声明:

xxxxxxxxxx
class Butterfly : public QWidget
{
    Q_OBJECT
public:
    explicit Butterfly(QWidget *parent = nullptr);
    void fly();
    void fly(int min,int max);
protected:
    void paintEvent(QPaintEvent*ev);
    void timerEvent(QTimerEvent*ev);
    void mouseRressEvent(QMouseEvent*ev);
    void mouseMoveEvent(QMouseEvent*ev);
    void enterEvent(QMouseEvent*ev);
signals:
private:
    QPixmap m_pixmap;
    int m_index=1;
    QPoint m_pt;
};

有两个自定义函数用来移动图片，五个重写的父类的事件处理器函数。私有成员变量第一个是为了切换图片，第二个是为了计数，在两个图片之间进行切换，第三个是用来计算坐标点的。

实现代码如下:

xxxxxxxxxx
Butterfly::Butterfly(QWidget *parent)
    : QWidget{parent}
{
    m_pixmap.load(":/1");
    //设置显示的大小和图片大小一样
    setFixedSize(m_pixmap.size());

    startTimer(100);//没个100ms调用一次
}
void Butterfly::fly()
{
    fly(10,30);
}
void Butterfly::fly(int min, int max)
{
    m_index++;
    if(m_index>2)
    {
        m_index=1;
    }
    QString name=QString(":/%1").arg(m_index);
    m_pixmap.load(name);
    update();//窗口刷新，就是调用paintEvent
    int stepX=QRandomGenerator::global()->bounded(min,max);
    int setpY=QRandomGenerator::global()->bounded(min,max);
    int curX=this->geometry().topLeft().x()+stepX;
    int curY=this->geometry().topLeft().y()+setpY;
    QScreen *desk=QApplication::primaryScreen();
    if(curX >= desk->geometry().right())
    {
        curX=desk->geometry().left();
    }
    if(curY >= desk->geometry().bottom())
    {
        curY=desk->geometry().top();
    }

    move(curX,curY);
}
//进行绘制
void Butterfly::paintEvent(QPaintEvent *ev)
{
    QPainter p(this);
    p.drawPixmap(rect(),m_pixmap);
}

void Butterfly::timerEvent(QTimerEvent *ev)
{
    fly();
}
//鼠标左键按下
void Butterfly::mouseRressEvent(QMouseEvent *ev)
{
    //先判断是否为左键
    if(ev->button()==Qt::LeftButton)
    {
        m_pt=ev->globalPos()-this->geometry().topLeft();//计算距离
    }
}
//鼠标移动
void Butterfly::mouseMoveEvent(QMouseEvent *ev)
{
    if(ev->buttons()&Qt::LeftButton)
    {
        this->move(ev->globalPos()-m_pt);
    }
}
void Butterfly::enterEvent(QMouseEvent *ev)
{
    fly(-200,200);
}

mainWindow主要如下:

xxxxxxxxxx
Butterfly*win=new Butterfly(this);
    win->move((width()-win->width())/2,(height()-win->height())/2);
    //去边框
    setWindowFlags(windowFlags()|Qt::FramelessWindowHint);
    //设置窗口透明
    setAttribute(Qt::WA_TranslucentBackground);
    //窗口最大化显示
    showMaximized();
    for(int i=0;i<100;i++)
    {
        Butterfly*win=new Butterfly(this);
        win->move(QRandomGenerator::global()->bounded(this->width()),
                  QRandomGenerator::global()->bounded(this->height()));
        win->show();
    }

去除边框和窗口透明这很重要，还有最大化显示。这里用的随机数是QRandomGenerator的静态方法global然后bounded是一个重载方法，可以指定最大与最小的随机范围，或者只指定一个参数。

强调一下鼠标移动的事件，写法如下:

xxxxxxxxxx
void MainWindow::mouseMoveEvent(QMouseEvent *event)
{
    QString msg=QString("move: x:%1,y:%2").arg(event->x()).arg(event->y());
    qDebug()<<msg;
}

这里只是简单的获取坐标打印，重写mouseMoveEvent事件

event事件分发器

xxxxxxxxxx
void event(QEvent *event);//函数原型

专门用来分发事件 一切事件都先交给它来判断属于谁，再分发到哪里处理事件。事件处理器函数那里讲过一些使用。

返回值是bool类型，如果返回的是true代表用户要处理这个时间，不向下分发事件了

我们可以通过event2022年6月14日22:26:53分发器 拦截事件，比如拦截鼠标按下的事件(单击)，如下:

xxxxxxxxxx
//先在头文件声明然后cpp实现，也就是重写，记住要先继承QWidget或者别的父类
bool event(QEvent *event);
//cpp:
bool Butterfly::event(QEvent *event)
{
    if(event->type()==QEvent::MouseButtonPress)
    {
        QString str = QString("Event拦截了鼠标按下");
        qDebug()<<str;
    }
}

我们使用的是之前讲事件处理函数和案例的QtEvent项目，在butterfly类里实测继承QWidget的类重写event是有效的(继承QLabel也行)。也是可以被拦截触发的。

但是我们这么写是有问题的，首先，我们这样写的话，表示要拦截此类所有的事件了，没有return分发，只是说当遇到点击事件会执行我们写的QDebug()代码。如果是别的事件则全部也不会执行，如果要让它正常执行，需要交给父类处理，也就是默认处置。对于需要拦截的事件也要记得返回true。正确如下:

xxxxxxxxxx
bool Butterfly::event(QEvent *event)
{
    if(event->type()==QEvent::MouseButtonPress)
    {
        QString str = QString("Event拦截了鼠标按下");
        qDebug()<<str;
        return true;//true代表用户自己处理这个事件，不向下分发
    }
    //其他事件交给父类处理 默认处置
    return QWidget::event(event);
}

QEvent::MouseButtonPress这是Qt框架里面的一个枚举的成员，Type枚举表示了很多的事件，图如下:

还有很多很多就不列举了。

总结它的作用:

1. 用于事件的分发
2. 事件的拦截(不推荐)

事件过滤器

通过事件过滤器可以在程序分发到even事件之前再做一次高级拦截。使用 两个步骤

1. 给控件安装事件过滤器
2. 重写eventfilter事件

xxxxxxxxxx
bool Butterfly::eventfilter(QEvent *event)
{
    if(event->type()==QEvent::MouseButtonPress)
    {
        QString str = QString("Event拦截了鼠标按下");
        qDebug()<<str;
        return true;//true代表用户自己处理这个事件，不向下分发
    }
    //其他事件交给父类处理 默认处置
    return QWidget::eventfilter(event);
}