Qt4.7中，线程，信号，事件的一点理解

最新推荐文章于 2024-05-19 20:20:58 发布
最新推荐文章于 2024-05-19 20:20:58 发布
阅读量2.5k 收藏 2
点赞数
分类专栏： QT 文章标签： qt thread signal timer delete user

这几天在学线程，觉得不错就转载一下。

 

首先，写个线程类，继承自QThread，该线程做的事情很简单：每两秒打印一次自己的线程id，由于我对Qt的console打印函数不太了解，这里还是使用c++的cout！

[cpp] view plain copy print ?
  1. #ifndef MYTHREAD_H   
  2. #define MYTHREAD_H   
  3.   
  4. #include <QThread>   
  5. #include <iostream>   
  6. using namespace std;  
  7.   
  8. class Mythread : public QThread  
  9. {  
  10.     Q_OBJECT  
  11. public:  
  12.     explicit Mythread(QObject *parent = 0);  
  13.   
  14. signals:  
  15.   
  16. public slots:  
  17.   
  18. protected:  
  19.     void run();  
  20.   
  21. };  
  22.   
  23. #endif // MYTHREAD_H  
#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>
#include <iostream>
using namespace std;

class Mythread : public QThread
{
    Q_OBJECT
public:
    explicit Mythread(QObject *parent = 0);

signals:

public slots:

protected:
	void run();

};

#endif // MYTHREAD_H

[cpp] view plain copy print ?
  1. #include "mythread.h"   
  2.   
  3. Mythread::Mythread(QObject *parent) :  
  4.     QThread(parent)  
  5. {  
  6. }  
  7.   
  8. void Mythread::run()  
  9. {  
  10.     while(1)  
  11.     {  
  12.         cout << "thread id: " << QThread::currentThreadId() << endl;  
  13.         sleep(2);  
  14.     }  
  15. }  
#include "mythread.h"

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

void Mythread::run()
{
	while(1)
	{
		cout << "thread id: " << QThread::currentThreadId() << endl;
		sleep(2);
	}
}

[cpp] view plain copy print ?
  1. #include <QtCore/QCoreApplication>   
  2. #include "mythread.h"   
  3.   
  4. int main(int argc, char *argv[])  
  5. {  
  6.     QCoreApplication a(argc, argv);  
  7.   
  8.     cout << "main thread id:" << QThread::currentThreadId() << endl;  
  9.   
  10.     Mythread thread;  
  11.     thread.start();  
  12.   
  13.     return a.exec();  
  14. }  
#include <QtCore/QCoreApplication>
#include "mythread.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    cout << "main thread id:" << QThread::currentThreadId() << endl;

    Mythread thread;
    thread.start();

    return a.exec();
}

这是一个Qt console进程，好了，运行一下，每隔两秒打印一次子线程id。


接下来，我们给线程设置定时器，来替换sleep

[cpp] view plain copy print ?
  1. #ifndef MYTHREAD_H   
  2. #define MYTHREAD_H   
  3.   
  4. #include <QThread>   
  5. #include <QTimer>   
  6. #include <iostream>   
  7. using namespace std;  
  8.   
  9. class Mythread : public QThread  
  10. {  
  11.     Q_OBJECT  
  12. public:  
  13.     explicit Mythread(QObject *parent = 0);  
  14.   
  15. signals:  
  16.   
  17. public slots:  
  18.     void mytimedout();  
  19.   
  20. protected:  
  21.     void run();  
  22.   
  23.     QTimer _timer;  
  24.   
  25. };  
  26.   
  27. #endif // MYTHREAD_H  
#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>
#include <QTimer>
#include <iostream>
using namespace std;

class Mythread : public QThread
{
    Q_OBJECT
public:
    explicit Mythread(QObject *parent = 0);

signals:

public slots:
	void mytimedout();

protected:
	void run();

	QTimer _timer;

};

#endif // MYTHREAD_H

[cpp] view plain copy print ?
  1. #include "mythread.h"   
  2.   
  3. Mythread::Mythread(QObject *parent) :  
  4.     QThread(parent)  
  5. {  
  6. }  
  7.   
  8. void Mythread::run()  
  9. {  
  10.     connect(&_timer, SIGNAL(timeout()), this, SLOT(mytimedout()));  
  11.     cout << "child thread id: " << QThread::currentThreadId() << endl;  
  12.     _timer.start(2000);  
  13.   
  14.     exec();  
  15.   
  16. }  
  17.   
  18. void Mythread::mytimedout()  
  19. {  
  20.     cout << "thread id: " << QThread::currentThreadId() << endl;  
  21. }  
#include "mythread.h"

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

void Mythread::run()
{
	connect(&_timer, SIGNAL(timeout()), this, SLOT(mytimedout()));
	cout << "child thread id: " << QThread::currentThreadId() << endl;
	_timer.start(2000);

	exec();

}

void Mythread::mytimedout()
{
	cout << "thread id: " << QThread::currentThreadId() << endl;
}

main与以前相同


发现并不能正常隔两秒打印一次。根据我查的资料，大概原因是：QTimer是在主线程里创建的，它发的信号只能与主线程相关的QObject来处理。详细信息还需要细看文档。


修改代码，我们在子线程里创建一个QTimer，并用它来发超时信号，子线程会阻塞在exec()这里，所以不用担心mytimer的生存期

将run改为如下：

[cpp] view plain copy print ?
  1. void Mythread::run()  
  2. {  
  3.     QTimer mytimer;  
  4.     connect(&mytimer, SIGNAL(timeout()), this, SLOT(mytimedout()));  
  5.     cout << "child thread id: " << QThread::currentThreadId() << endl;  
  6.     mytimer.start(2000);  
  7.   
  8.     exec();  
  9.   
  10. }  
void Mythread::run()
{
	QTimer mytimer;
	connect(&mytimer, SIGNAL(timeout()), this, SLOT(mytimedout()));
	cout << "child thread id: " << QThread::currentThreadId() << endl;
	mytimer.start(2000);

	exec();

}

此时可以打印了，不过，我们发现打印的时候，显示的是主线程id，也就是说，mytimedout这个函数是在主线程里执行的。根据所查资料，这里大概是因为：工作线程在创建的时候，线程的事件处理，是依附在创建者身上的，我们需要在创建之后，调用QObject::moveToThread()来改变依附性，

main修改如下：

[cpp] view plain copy print ?
  1. #include <QtCore/QCoreApplication>   
  2. #include "mythread.h"   
  3.   
  4. int main(int argc, char *argv[])  
  5. {  
  6.     QCoreApplication a(argc, argv);  
  7.   
  8.     cout << "main thread id:" << QThread::currentThreadId() << endl;  
  9.   
  10.     Mythread thread;  
  11.     thread.start();  
  12.     thread.moveToThread(&thread);  
  13.   
  14.     return a.exec();  
  15. }  
#include <QtCore/QCoreApplication>
#include "mythread.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

	cout << "main thread id:" << QThread::currentThreadId() << endl;

	Mythread thread;
	thread.start();
	thread.moveToThread(&thread);

    return a.exec();
}

这时候，便由子线程自己来打印了


接下来看下事件，QEvent！我们让子线程往主线程发送QEvent，主线程接受到后，打印信息表示接收到了。

要让主线程可以处理自定义事件，需要从QCoreApplication继承一个类，并改写虚函数event(QEvent *eve)

[cpp] view plain copy print ?
  1. #ifndef MYAPP_H   
  2. #define MYAPP_H   
  3.   
  4. #include <QCoreApplication>   
  5. #include <mythread.h>   
  6.   
  7. class Myapp : public QCoreApplication  
  8. {  
  9.     Q_OBJECT  
  10. public:  
  11.     explicit Myapp(int argc, char* argv[], QObject *parent = 0);  
  12.   
  13.     bool event( QEvent * e );  
  14.   
  15. signals:  
  16.   
  17. public slots:  
  18.   
  19. };  
  20.   
  21. #endif // MYAPP_H  
#ifndef MYAPP_H
#define MYAPP_H

#include <QCoreApplication>
#include <mythread.h>

class Myapp : public QCoreApplication
{
    Q_OBJECT
public:
	explicit Myapp(int argc, char* argv[], QObject *parent = 0);

	bool event( QEvent * e );

signals:

public slots:

};

#endif // MYAPP_H

[cpp] view plain copy print ?
  1. #include "myapp.h"   
  2.   
  3. Myapp::Myapp(int argc, char* argv[], QObject *parent) :  
  4.     QCoreApplication(argc, argv)  
  5. {  
  6. }  
  7.   
  8. bool Myapp::event( QEvent * e )  
  9. {  
  10.     if(e->type() == (mytype1)){  
  11.         cout << "thread id:" << QThread::currentThreadId() << "recv a event, type is:" << e->type() << endl;  
  12.     }  
  13.     return QCoreApplication::event(e);  
  14. }  
#include "myapp.h"

Myapp::Myapp(int argc, char* argv[], QObject *parent) :
	QCoreApplication(argc, argv)
{
}

bool Myapp::event( QEvent * e )
{
	if(e->type() == (mytype1)){
		cout << "thread id:" << QThread::currentThreadId() << "recv a event, type is:" << e->type() << endl;
	}
	return QCoreApplication::event(e);
}

子线程里，发送事件

[cpp] view plain copy print ?
  1. #ifndef MYTHREAD_H   
  2. #define MYTHREAD_H   
  3.   
  4. #include <QThread>   
  5. #include <QTimer>   
  6. #include <QEvent>   
  7. #include <iostream>   
  8. using namespace std;  
  9.   
  10. enum Type{ mytype1 = QEvent::User+1, mytype2 }; // 这是我自定义的事件类型。这里有个问题，可能是qt的bug，如果我编译成功了，然后改mytype1=QEvent::User，再编译运行，就会收不到事件   
  11.   
  12.   
  13. class Mythread : public QThread  
  14. {  
  15.     Q_OBJECT  
  16. public:  
  17.     explicit Mythread(QObject *parent = 0);  
  18.   
  19. signals:  
  20.   
  21. public slots:  
  22.     void mytimedout();  
  23.   
  24. protected:  
  25.     void run();  
  26.   
  27.     QTimer _timer;  
  28.   
  29. };  
  30.   
  31. #endif // MYTHREAD_H  
#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>
#include <QTimer>
#include <QEvent>
#include <iostream>
using namespace std;

enum Type{ mytype1 = QEvent::User+1, mytype2 }; // 这是我自定义的事件类型。这里有个问题，可能是qt的bug，如果我编译成功了，然后改mytype1=QEvent::User，再编译运行，就会收不到事件


class Mythread : public QThread
{
    Q_OBJECT
public:
    explicit Mythread(QObject *parent = 0);

signals:

public slots:
	void mytimedout();

protected:
	void run();

	QTimer _timer;

};

#endif // MYTHREAD_H

[cpp] view plain copy print ?
  1. #include <QCoreApplication>   
  2. #include "mythread.h"   
  3.   
  4.   
  5. Mythread::Mythread(QObject *parent) :  
  6.     QThread(parent)  
  7. {  
  8. }  
  9.   
  10. void Mythread::run()  
  11. {  
  12.     QTimer mytimer;  
  13.     connect(&mytimer, SIGNAL(timeout()), this, SLOT(mytimedout()));  
  14.     cout << "child thread id: " << QThread::currentThreadId() << endl;  
  15.   
  16.     mytimer.start(2000);  
  17.   
  18.     exec();  
  19.   
  20. }  
  21.   
  22. void Mythread::mytimedout()  
  23. {  
  24.     cout << "thread id: " << QThread::currentThreadId() << endl;  
  25.     QEvent *eve = new QEvent((QEvent::Type)(mytype1));  
  26.     QCoreApplication::postEvent(QCoreApplication::instance(), eve);  
  27. }  
#include <QCoreApplication>
#include "mythread.h"


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

void Mythread::run()
{
	QTimer mytimer;
	connect(&mytimer, SIGNAL(timeout()), this, SLOT(mytimedout()));
	cout << "child thread id: " << QThread::currentThreadId() << endl;

	mytimer.start(2000);

	exec();

}

void Mythread::mytimedout()
{
	cout << "thread id: " << QThread::currentThreadId() << endl;
	QEvent *eve = new QEvent((QEvent::Type)(mytype1));
	QCoreApplication::postEvent(QCoreApplication::instance(), eve);
}

[cpp] view plain copy print ?
  1. #include <QtCore/QCoreApplication>   
  2. #include "mythread.h"   
  3. #include "myapp.h"   
  4.   
  5. int main(int argc, char *argv[])  
  6. {  
  7.     Myapp a(argc, argv);  
  8.   
  9.     cout << "reg value:" << QEvent::registerEventType(mytype1) << endl; // 这里注册一下，看该类型的事件是否被别人注册过了，避免混淆   
  10.     cout << "reg value:" << QEvent::registerEventType(mytype2) << endl;  
  11.   
  12.     cout << "main thread id:" << QThread::currentThreadId() << endl;  
  13.   
  14.     Mythread thread;  
  15.     thread.start();  
  16.     thread.moveToThread(&thread);  
  17.   
  18.     return a.exec();  
  19. }  
#include <QtCore/QCoreApplication>
#include "mythread.h"
#include "myapp.h"

int main(int argc, char *argv[])
{
	Myapp a(argc, argv);

	cout << "reg value:" << QEvent::registerEventType(mytype1) << endl; // 这里注册一下，看该类型的事件是否被别人注册过了，避免混淆
	cout << "reg value:" << QEvent::registerEventType(mytype2) << endl;

	cout << "main thread id:" << QThread::currentThreadId() << endl;

	Mythread thread;
	thread.start();
	thread.moveToThread(&thread);

    return a.exec();
}


我们在Mythread::mytimedout()里new 了一个QEvnet对象，却没有去delete它，那么它会内存泄漏吗？其实不会，因为这个事件被发出去后，处理该事件的对象在处理完该事件后，会delete它，比如这里是

[cpp] view plain copy print ?
  1. bool Myapp::event( QEvent * e )  
  2. {  
  3.     if(e->type() == (mytype1)){  
  4.         cout << "thread id:" << QThread::currentThreadId() << "recv a event, type is:" << e->type() << endl;  
  5.     }  
  6.     return QCoreApplication::event(e);  
  7. }  
bool Myapp::event( QEvent * e )
{
	if(e->type() == (mytype1)){
		cout << "thread id:" << QThread::currentThreadId() << "recv a event, type is:" << e->type() << endl;
	}
	return QCoreApplication::event(e);
}
return QCoreApplication::event(e); 这里是转给父类去处理，估计最终会由QObject的event函数来delete掉。


我们可以自己写个类继承自QEvent，QEvent的析构函数为虚。我们的类继承它，别人delete这个类时，除了会执行自己的析构函数以外，也会调用QEvent的析构函数。

[cpp] view plain copy print ?
  1. #ifndef MYTHREAD_H   
  2. #define MYTHREAD_H   
  3.   
  4. #include <QThread>   
  5. #include <QTimer>   
  6. #include <QEvent>   
  7. #include <iostream>   
  8. using namespace std;  
  9.   
  10. enum Type{ mytype1 = QEvent::User+1, mytype2 };  
  11.   
  12. class Myevent:public QEvent  
  13. {  
  14. public:  
  15.     Myevent(QEvent::Type type):QEvent(type){}  
  16.     ~Myevent(){  
  17.         cout << "thread id: " << QThread::currentThreadId() << "destroy event, type is:" << type() << endl;  
  18.     }  
  19. };  
  20.   
  21.   
  22. class Mythread : public QThread  
  23. {  
  24.     Q_OBJECT  
  25. public:  
  26.     explicit Mythread(QObject *parent = 0);  
  27.   
  28. signals:  
  29.   
  30. public slots:  
  31.     void mytimedout();  
  32.   
  33. protected:  
  34.     void run();  
  35.   
  36.     QTimer _timer;  
  37.   
  38. };  
  39.   
  40. #endif // MYTHREAD_H  
#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>
#include <QTimer>
#include <QEvent>
#include <iostream>
using namespace std;

enum Type{ mytype1 = QEvent::User+1, mytype2 };

class Myevent:public QEvent
{
public:
	Myevent(QEvent::Type type):QEvent(type){}
	~Myevent(){
		cout << "thread id: " << QThread::currentThreadId() << "destroy event, type is:" << type() << endl;
	}
};


class Mythread : public QThread
{
    Q_OBJECT
public:
    explicit Mythread(QObject *parent = 0);

signals:

public slots:
	void mytimedout();

protected:
	void run();

	QTimer _timer;

};

#endif // MYTHREAD_H

[cpp] view plain copy print ?
  1. void Mythread::mytimedout()  
  2. {  
  3.     cout << "thread id: " << QThread::currentThreadId() << endl;  
  4.     QEvent *eve = new Myevent((QEvent::Type)(mytype1));  
  5.     QCoreApplication::postEvent(QCoreApplication::instance(), eve);  
  6. }  
void Mythread::mytimedout()
{
	cout << "thread id: " << QThread::currentThreadId() << endl;
	QEvent *eve = new Myevent((QEvent::Type)(mytype1));
	QCoreApplication::postEvent(QCoreApplication::instance(), eve);
}

可以看到Myapp的线程在处理完事件后，delete掉了事件，因为调用了Myevent的析构函数。



最后，我们让父类接收到mytype1事件后，往子线程发一个mytype2事件。

类Mythread需要重载event方法

[cpp] view plain copy print ?
  1. bool Mythread::event( QEvent * e )  
  2. {  
  3.     switch(e->type())  
  4.     {  
  5.     case mytype2:  
  6.         cout << "child thread:" << QThread::currentThreadId() << "recv a event, type is:" << e->type() << endl;  
  7.         break;  
  8.     default:  
  9.         break;  
  10.     }  
  11.     return QThread::event(e);  
  12. }  
bool Mythread::event( QEvent * e )
{
	switch(e->type())
	{
	case mytype2:
		cout << "child thread:" << QThread::currentThreadId() << "recv a event, type is:" << e->type() << endl;
		break;
	default:
		break;
	}
	return QThread::event(e);
}

Myapp的event变为

[cpp] view plain copy print ?
  1. bool Myapp::event( QEvent * e )  
  2. {  
  3.     if(e->type() == (mytype1)){  
  4.         cout << "thread id:" << QThread::currentThreadId() << "recv a event, type is:" << e->type() << endl;  
  5.         QEvent *eve = new Myevent((QEvent::Type)mytype2);  
  6.         postEvent(_recv, eve);  
  7.     }  
  8.     return QCoreApplication::event(e);  
  9. }  
bool Myapp::event( QEvent * e )
{
	if(e->type() == (mytype1)){
		cout << "thread id:" << QThread::currentThreadId() << "recv a event, type is:" << e->type() << endl;
		QEvent *eve = new Myevent((QEvent::Type)mytype2);
		postEvent(_recv, eve);
	}
	return QCoreApplication::event(e);
}

这里_recv是子线程的QObject指针

[cpp] view plain copy print ?
  1. void setReceive(QObject *obj){  
  2.         _recv = obj;  
  3.     }  
  4. protected:  
  5.     QObject *_recv;  
void setReceive(QObject *obj){
		_recv = obj;
	}
protected:
	QObject *_recv;

main函数

[cpp] view plain copy print ?
  1. #include <QtCore/QCoreApplication>   
  2. #include "mythread.h"   
  3. #include "myapp.h"   
  4.   
  5. int main(int argc, char *argv[])  
  6. {  
  7.     Myapp a(argc, argv);  
  8.   
  9.     cout << "reg value:" << QEvent::registerEventType(mytype1) << endl;  
  10.     cout << "reg value:" << QEvent::registerEventType(mytype2) << endl;  
  11.   
  12.     cout << "main thread id:" << QThread::currentThreadId() << endl;  
  13.   
  14.     Mythread thread;  
  15.     a.setReceive(&thread);  
  16.   
  17.     thread.start();  
  18.     thread.moveToThread(&thread);  
  19.   
  20.     return a.exec();  
  21. }  
#include <QtCore/QCoreApplication>
#include "mythread.h"
#include "myapp.h"

int main(int argc, char *argv[])
{
	Myapp a(argc, argv);

	cout << "reg value:" << QEvent::registerEventType(mytype1) << endl;
	cout << "reg value:" << QEvent::registerEventType(mytype2) << endl;

	cout << "main thread id:" << QThread::currentThreadId() << endl;

	Mythread thread;
	a.setReceive(&thread);

	thread.start();
	thread.moveToThread(&thread);

    return a.exec();
}

这样，子线程每2秒处理一个超时信号，打印相关信息和往主线程发事件mytype1，主线程接收到该事件后，往子线程发一个mytype2的事件。子线程处理mytype2事件，打印信息

注意：

[cpp] view plain copy print ?
  1. thread.moveToThread(&thread) // 这不是一个好的方法，这里作为例子这么用可以更快速让例子运行起来  
thread.moveToThread(&thread) // 这不是一个好的方法，这里作为例子这么用可以更快速让例子运行起来

参考：

http://www.qtcn.org/bbs/simple/?t32303.html

http://www.cnblogs.com/tankery/archive/2011/03/09/2004561.html

http://www.cnblogs.com/andreitang/archive/2011/08/03/2125815.html

lpp1989
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[QT编程系列-26]：多线程机制 - QT线程间通信与线程的事件队列event queue、QueuedConnection
文火冰糖（王文兵）的博客
07-19 3020
可以使用压缩算法进行数据压缩，或使用规则或过滤器对数据进行筛选，只选择需要的数据进行传输或处理。通过将待发送的数据分配给线程池中的空闲线程，可以平衡工作负载，并确保发送数据的速率得到控制。通过以上方法，可以解决发送数据线程和接收数据线程之间的不平衡问题，确保数据能够按时传送和处理。同时，由于Qt的信号和槽机制是基于事件循环的，因此在使用线程进行数据传递时，可能需要处理事件循环以便及时响应和处理信号槽连接。需要注意的是，信号和槽机制可以跨越线程边界，在不同的线程之间进行通信。
[QT编程系列-27]：多线程机制 - 信号与槽实现不同对象之间通信的五种情形：线程内同步通信、线程内异步通信、线程间异步通信
文火冰糖（王文兵）的博客
07-19 2807
直接连接，当SenderObject对象发射sendMessage信号时，信号首先被缓存到线程的信号队列，并直接返回，ReceiverObject对象的onMessageReceived槽函数将被线程的信号队里查询函数调用，并传递相应的参数，因此会出现异步延时！总而言之，线程的信号队列是Qt中跨线程异步通信的机制，它通过将信号封装为事件对象，将事件放入目标线程的信号队列中，并在目标线程的事件循环中处理，实现了线程间的安全通信。接收者线程的事件循环：目标线程中需要运行事件循环，才能及时处理信号队列中的事件。
JavaScript中事件处理的两种绑定方式
qq_48783543的博客
10-17 275
常见的两种绑定方式（就是事件是如何加到网页中的方式） 第一种是直接在标签中加一个属性后面赋值一个函数或者方法 第二种就是将标签加一个属性，然后通过加JavaScript代码的方式绑定事件 事件的组成 事件源，事件，事件处理程序组成事件 事件源：就是在网页中任何可以看到的东西 就是任何一个标签 事件：比如说点击事件：就是上面的图片上面加的事件 事件处理程序：就是事件要执行的那个方法 这三者一定要分清 ...
Qt5 多线程 | 子线程向主线程发射信号 | 操作UI 的实现 | 全流程教程
qq_42885747的博客
01-13 6297
实现多线程: A.为子线程创建一个类 1.新建头文件:thread.h 接下来的内容写在该文件中，也可以写在mainwindow.h里，但是不推荐 2.添加引用： #include <QThread> 3.定义类 , 继承QThread,类名可以自定义 4.添加宏定义Q_OBJECT 5.定义 run() 函数 ，注意函数名就是run，不可自定义 class MyThread ...
qt4.7的api
10-09
1. **核心框架**：这是Qt的基础，提供了数据结构、事件处理、线程支持和网络编程等功能。核心类如`QObject`、`QEvent`、`QString`、`QList`等在此部分定义，它们构成了Qt对象模型的基础。 2. **图形视图框架**：这...
Qt4.7连接MySQL 驱动
11-26
本文将详细介绍如何在Qt4.7中使用MySQL驱动，以及涉及到的库文件。 首先，"Qt4.7连接MySQL驱动"是指在Qt 4.7版本中，为了能够与MySQL数据库进行通信，需要安装并配置特定的驱动。Qt4提供了QSqlDatabase模块，该模块...
Qt4.7开发网络应用程序
12-10
本教程重点聚焦于Qt 4.7版本，它虽然已经较为陈旧，但对于理解Qt的基本原理和网络编程概念仍然极具价值。 Qt 4.7包含了一系列库和工具，允许开发者使用C++编写程序，并支持Windows、Linux、macOS等多种操作系统。其...
qt5.9.4用qt4.7的ftp功能ftp已编译成lib库
08-16
在本文中，我们将深入探讨如何在QT 5.9.4中使用已经为QT 4.7编译的FTP功能，以及如何利用提供的源码和demo来扩展FTP库，以创建更高效、易用的FTP客户端。 FTP（File Transfer Protocol）是一种用于在网络上进行文件...
QT4.7 + ZLIB压缩解压测试工程
11-14
QT4.7与ZLIB库结合使用，是开发者在C++环境中进行数据压缩与解压缩操作的一种常见方式。ZLIB库是一个开源的压缩库，它提供了高效的数据压缩和解压缩功能，广泛应用于软件开发，特别是在文件传输、网络通信等领域。QT...
【原创】QT多线程和自定事件自我总结
weixin_34212189的博客
04-12 89
最近又搞上了QT，还是恶心的QT3（因为公司规定要QT3）。因为项目用到了多线程，子线程要向主界面线程传值。用到了多线程和自定事件。现总结如下： 一、编写自定义的事件类 先看代码: #include <qevent.h> class MyEvent : public QCustomEvent { public: MyEvent( int ty...
对qt多线程以及事件投递的理解
热门推荐
shaochat的专栏
12-16 1万+
用QThread启动线程的良好方法以及理解。
【原】qt4 子线程给主线程发消息，发数据，通信，qthread gui postevent emit
LYJ个人博客，记录技术、八卦、生活，分享各种心得，期待与朋友们一同进步
10-01 6565
【转帖请注明出处：blog.csdn.net/lanmanck】 用了qthread后，自然想起给gui线程发送数据。在qt4中，QCustomEvent已经不使用了。因为qthread是从QObject继承的，所以可以使用signal,slot机制来通信。 1、在线程定义signal： class aa:public QThread{Q_OBJECT...
Qt线程间通信-自定义事件
IT1995的博客
07-15 4937
线程间通信：1.自定义事件：postEvent()；2.信号与槽【本质也是通过自定义事件实现的】注意：每个线程都有自己的事件循环自定义事件： 1.从QEvent继承； 2.registerEventType()； //会返回全局唯一的事件类型 3.QCoreApplication::postEvent()；//异步方式发送事件，Qt本身接管事件周期，在事件处理后就会销毁他，所以new了后不要del...
第八十五课、多线程与界面组件的通信（下）------------------狄泰软件学院
zjy900507的博客
10-15 252
一、多线程与界面组件的通信 1、子线程更改界面组件状态的本质 （1）、子线程发射信号通知主线程界面更新请求 （2）、主线程根据具体信号以及信号参数对界面组件进行修改 2、另一种子线程通知主线程的方式 ：发送自定义事件 （1）、自定义事件用于描述界面更新细节 （2）、在主窗口类中重写事件处理函数event （3）、使用postEvent函数（异步方式）发送自定义事件类对象（抛到应用程序的事件队列，然后分发出去） A、子线程指定接收消息的对象为主窗口对象 B、在event事件处理函数中更新
Qt中多线程与界面组件地通信（2） -- 自定义事件机制
gkfdkl的博客
03-15 397
Qt中另一种多线程与界面组件通信的方法 上一节中讲到了使用Qt平台独有的信号槽机制，实现子线程与界面组件的通信，来间接操作界面组件。那么Qt中有没有其他方式能够实现这一功能呢？或者其他不支持信号槽机制的平台该怎么实现子线程操作界面组件呢？ 还是借助Qt平台，我们很容易就能想到另一种可以跨线程的通信方式：事件。Qt平台支持比较完善的事件系统，当然也能发送自定义的事件，发送自定义事件的方式主要依靠两个函数：sendEvent()和postEnent()。两者的区别主要有如下几点： sendEvent()会立即
qt5子线程向主线程发信号（被ChatGPT拯救的一天）
最新发布
lwhard的博客
05-19 367
首先，我们定义一个类，它继承自QThread。这个类有一个信号progress，用于向主线程发送进度更新。cpp复制Q_OBJECTpublic:signals:protected:i <= 100;++i) {// 模拟一些工作// 向主线程发送信号。
qt qthead里如何响应信号_在Qt（C++）中使用QThread实现多线程
weixin_39980353的博客
12-21 256
1. 引言多线程对于需要处理耗时任务的应用很有用，一方面响应用户操作、更新界面显示，另一方面在“后台”进行耗时操作，比如大量运算、复制大文件、网络传输等。使用Qt框架开发应用程序时，使用QThread类可以方便快捷地创建管理多线程。而多线程之间的通信也可使用Qt特有的“信号-槽”机制实现。下面的说明以文件复制为例。主线程负责提供交互界面，显示复制进度等；子线程负责复制文件。最后附有可以执行的代码。...
Qt4.7 多线程处理
weixin_45304839的博客
01-14 83
Qt4.7多线程处理，不建议使用，往后会慢慢更新掉，可以用Qt5的多线程写法，在主页
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值