QT (启动一个线程)

不一传说

已于 2022-02-22 08:23:23 修改

阅读量2.5k

点赞数

文章标签： qt 开发语言 c++

于 2022-02-16 08:52:42 首次发布

原文链接：https://blog.csdn.net/dianzishi123/article/details/84674825?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164497230316780271510554%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=164497230316780271510554&biz_

版权

启动一个线程的步骤:
(1) 创建一个自己的线程类继承QT中的QThread类创建线程类WorkThread;
(2) 在自己的WorkThreak类中重新实现run()函数, 该函数是一个死循环, 主要是完成自己需要的功能代码
(3) 使用自己的类WorkThread 实例一个对象,也就是用该类创建一个变量如: WorkThread *task = new WorkThread (this);
(4) 然后通过start()函数启动这个线程, 如task->start();启动该线程
重载的run()函数就是一个独立运行线程, 要想实现多线程就多次继承QThread类在不同的类中的run()函数中实现不同的功能

当然不止只重载 run() 函数, 可以重载 start() 函数为一个槽函数,使用按钮启动该线程或者连接某个信号启动该线程

实现如下

例子1

(1) 创建类WorkThread继承QThread类;

WorkThread.h文件:


   
   
     
     
      
      
     
     
     
     
      
      
       
       #ifndef WORKTHREAD_H
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #define WORKTHREAD_H
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include <QThread>
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       class 
       
       WorkThread : 
       
       public QThread
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       public:
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       WorkThread();
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       private:
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       virtual void run();
       
       //任务处理线程
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       public:
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       int workCount;
       
       //计数
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       signals:
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       public slots:
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       };
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #endif // WORKTHREAD_H

WorkThread.cpp文件:


   
   
     
     
      
      
     
     
     
     
      
      
       
       #include "WorkThread.h"
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include <QDebug>
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       WorkThread::
       
       WorkThread()
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           workCount = 
       
       0;
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       //(2) run()重新实现
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       void WorkThread::run()
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       while(
       
       true)
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           {
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
               workCount++;
      
      
     
     

     
     
      
      
     
     
     
     
      
              
       
       if(workCount>=
       
       1000) workCount=
       
       0;
      
      
     
     

     
     
      
      
     
     
     
     
      
              
       
       qDebug()<<
       
       "WorkThread"<<workCount;
      
      
     
     

     
     
      
      
     
     
     
     
      
              
       
       sleep(
       
       1);
       
       //线程 睡眠一秒一次
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           }
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }

main.cpp文件:


   
   
     
     
      
      
     
     
     
     
      
      
       
       #include <QCoreApplication> //不创建GUI界面
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include <QDebug>
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include "WorkThread.h"
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       int main(int argc,char** argv)
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       QCoreApplication app(argc,argv);
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           WorkThread *task = 
       
       new WorkThread; 
       
       // (3) 创建一个 WorkThread 对象
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       qDebug()<<
       
       "线程测试开始:";
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           task->
       
       start();
       
       //启动该线程 (4)
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       qDebug()<<
       
       "线程测试结束:";
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       return app.
       
       exec();
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }

工程管理文件 Thread.pro文件:


   
   
     
     
      
      
     
     
     
     
      
      
       
       HEADERS += \
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           WorkThread.h
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       SOURCES += \
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           WorkThread.cpp \
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           main.cpp

工程目录;

程序运行状态:

测试上面的线程使用


   
   
     
     
      
      
     
     
     
     
      
      
       
       task->quit();
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       task->wait();

线程也不会终止, 开启的新线程是死循环啊

例子2

工程文件:

1. 主要想法就是在子线程中的循环设定一个条件,当想停止这个线程时,就改变线程循环的条件

如: while(isStop==false) 只需要改变 "isStop " 的状态就可以实现线程的循环了

2. 实现一个修改这个标志的函数,方便外部修改

mythread.cpp文件:


   
   
     
     
      
      
     
     
     
     
      
      
       
       #include "mythread.h"
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include <QThread>
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include <QDebug>
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       myThread::
       
       myThread(QObject *parent) : 
       
       QObject(parent)
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           isStop=
       
       false;
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       void myThread::myTimeout()
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       while(isStop==
       
       false)
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           {
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
               QThread::
       
       sleep(
       
       1);
      
      
     
     

     
     
      
      
     
     
     
     
      
              
       
       emit mySignal();
      
      
     
     

     
     
      
      
     
     
     
     
      
              
       
       qDebug()<<
       
       "子线程号:"<<QThread::
       
       currentThread();
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
              
       
       if(
       
       true==isStop)
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
               {
      
      
     
     

     
     
      
      
     
     
     
     
      
                  
       
       break;
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
               }
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           }
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       //修改线程工作标志的,公共函数
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       void myThread::setFlag(bool flag)
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           isStop=flag;
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }

mythread.h文件


   
   
     
     
      
      
     
     
     
     
      
      
       
       #ifndef MYTHREAD_H
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #define MYTHREAD_H
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include <QObject>
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       class 
       
       myThread : 
       
       public QObject
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           Q_OBJECT
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       public:
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       explicit myThread(QObject *parent = nullptr);
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       void myTimeout();
       
       //线程处理函数, 也就是实际开启的线程
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       void setFlag(bool flag=true);
       
       //设置线程中标志,用于停止线程
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       signals:
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       void mySignal(); 
       
       //定义一个信号,在该子线程中每秒发射一次该信号
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       private:
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       bool isStop;
       
       //线程工作标志
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       public slots:
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       };
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #endif // MYTHREAD_H

3. 在外部只要调用这个修改标志的公共函数,同时调用 task->quit(); 和 task->wait(); 共同终止一个线程

widget.cpp文件:


   
   
     
     
      
      
     
     
     
     
      
      
       
       #include "widget.h"
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include "ui_widget.h"
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include <QDebug>
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       Widget::
       
       Widget(QWidget *parent) :
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       QWidget(parent),
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       ui(
       
       new Ui::Widget)
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           ui->
       
       setupUi(
       
       this);
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       //动态分配空间, 不能指定父对象
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           myT = 
       
       new myThread;
       
       //指定父对象后下面不可以在加入子线程中,下面的子线程相当于其父对象
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           thread = 
       
       new 
       
       QThread(
       
       this);
       
       //创建子线程
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           myT->
       
       moveToThread(thread);
       
       //把自定义的线程加入到子线程中
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       connect(myT,&myThread::mySignal,
       
       this,&Widget::dealSignal);
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       qDebug()<<
       
       "主线程号:"<<QThread::
       
       currentThread();
       
       //打印主线程号
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       connect(
       
       this,&Widget::startThread,myT,&myThread::myTimeout);
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       connect(
       
       this,&Widget::destroyed,
       
       this,&Widget::deadClose);
       
       //右上角"X"关了窗口线程还在运行
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       //线程处理函数内部,不允许操作图形界面
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       //connect()第五个参数的作用,连接方式 默认 队列 直接
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       //多线程才有意义
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       Widget::~
       
       Widget()
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       delete ui;
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       //对话框右上角的 叉号 关闭事件触发的槽函数
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       void Widget::deadClose()
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       on_buttonStop_clicked();
       
       //停止线程
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       delete myT;     
       
       //释放线程空间
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       //子线程信号触发的主线程中的槽函数
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       void Widget::dealSignal()
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       static 
       
       int i=
       
       0;
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           i++;
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           ui->lcdNumber->
       
       display(i);
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       //start按钮触发槽函数
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       void Widget::on_buttonStart_clicked()
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       if(thread->
       
       isRunning()==
       
       true)
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           {
      
      
     
     

     
     
      
      
     
     
     
     
      
              
       
       return;
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           }
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           thread->
       
       start();
       
       //启动线程,但是没有启动线程处理函数
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           myT->
       
       setFlag(
       
       false);
       
       //修改线程标志后才真启动了线程
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       //不能直接调用线程处理函数
      
      
     
     

     
     
      
      
     
     
     
     
      
         
       
       // myT->myTimeout();//直接调用,导致,线程处理函数和主线程是在同一线程
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       //只能通过signal-slot方式调用
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       emit startThread();
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       //stop按钮触发槽函数
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       void Widget::on_buttonStop_clicked()
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       if(thread->
       
       isRunning()==
       
       false)
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           {
      
      
     
     

     
     
      
      
     
     
     
     
      
              
       
       return ;
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           }
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           myT->
       
       setFlag(
       
       true);
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           thread->
       
       quit();
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           thread->
       
       wait();
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }

widget.h文件


   
   
     
     
      
      
     
     
     
     
      
      
       
       #ifndef WIDGET_H
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #define WIDGET_H
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include <QWidget>
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include "mythread.h"
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include <QThread>
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       namespace Ui {
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       class 
       
       Widget;
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       class 
       
       Widget : 
       
       public QWidget
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           Q_OBJECT
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       public:
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       explicit Widget(QWidget *parent = 0);
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           ~
       
       Widget();
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       private slots:
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       void on_buttonStart_clicked();
       
       //槽
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       void on_buttonStop_clicked(); 
       
       //槽
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       void dealSignal();  
       
       //子线程信号触发的主线程中的槽函数
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       void deadClose();   
       
       //对话框右上角的 叉号 关闭事件触发的槽函数
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       signals:
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       void startThread();
       
       //启动子线程的信号
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       private:
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           Ui::Widget *ui;
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           myThread *myT;
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           QThread *thread; 
       
       //定义一个线程对象指针在构造函数中分配空间
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       };
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #endif // WIDGET_H

main.cpp文件


   
   
     
     
      
      
     
     
     
     
      
      
       
       #include "widget.h"
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       #include <QApplication>
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       int main(int argc, char *argv[])
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       {
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       QApplication a(argc, argv);
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           Widget w;
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
           w.
       
       show();
      
      
     
     

     
     
      
      
     
     
     
     
      
       
      
      
     
     

     
     
      
      
     
     
     
     
      
          
       
       return a.
       
       exec();
      
      
     
     

     
     
      
      
     
     
     
     
      
      
       
       }