Qt中信号槽形参值传递，引用传递，指针传递的实例及总结

在同一个线程中

当信号和槽都在同一个线程中时，值传递参数和引用传递参数有区别： 值传递会复制对象；（测试时，打印传递前后的地址不同） 引用传递不会复制对象；（测试时，打印传递前后的地址相同）

不在同一个线程中

当信号和槽不在同一个线程中时，分两种情况。 1、connect时使用AutoConnection（跨线程默认是QueuedConnection）：值传递参数和引用传递参数没有区别，都会复制对象；（测试时，打印传递前后的地址不同） 2、connect时使用DirectConnection，测试结果和在同一线程中的结果相同

转自：https://blog.csdn.net/u010168781/article/details/82108522

emit发射信号 在信号中以&引用作为参数

以引用作为参数一定要注意，在第二次发射信号的时候，引用的实体已经不存在了。

所以，如果想让每一次发射的信号中参数的值都保存下来，不能是&引用和*指针作为参数，而应该使用值传递。

这样每次发射信号的值都能够保存下来。

Qt 信号槽传递指针实例

指针定义

#ifndef DEFINE_H
#define DEFINE_H
#include <QMetaType>

struct Message{
    int index;
    int *data;
};
typedef int* iPoint;
Q_DECLARE_METATYPE(Message)
#endif // OBJECT1_H

业务模块1

#ifndef OBJECT1_H
#define OBJECT1_H
#include <QObject>
#include "define.h"
class object1 : public QObject
{
    Q_OBJECT
public:
    explicit object1(QObject *parent = nullptr);
signals:
    void sigSendMsg(const Message&);
public slots:
    void onRevPointer(iPoint);
private:
    class QThread *worker;
    int index_;
};
#endif // OBJECT1_H




#include "object1.h"
#include <QThread>
#include <QTimer>
#include <QDebug>

object1::object1(QObject *parent) : QObject(parent)
{
    index_ = 0;
    QTimer *t = new QTimer(this);
    t->setInterval(1000);
    connect(t,&QTimer::timeout,this,[this](){
        Message msg;
        msg.index = ++index_;
        msg.data = new int[1024*1024];
        sigSendMsg(msg);
        qDebug()<<"send thread:"<<QThread::currentThreadId();
    });

    t->start();
    worker = new QThread();
    worker->setObjectName("object1");
    this->moveToThread(worker);
    worker->start();
}

void object1::onRevPointer(iPoint p)
{
    qDebug()<<p[0];
    delete p;//不删除会有内存泄露
    qDebug()<<Q_FUNC_INFO;
}

业务模块2

#ifndef OBJECT2_H
#define OBJECT2_H
#include <QObject>
#include "define.h"
class object2 : public QObject
{
    Q_OBJECT
public:
    explicit object2(QObject *parent = nullptr);
public slots:
    void onRevMsg(const Message&);
signals:
    void sigSendPointer(iPoint);
private:
    class QThread *worker;
    int index_;
};
#endif // OBJECT2_H
//
#include "object2.h"
#include <QThread>
#include <QTimer>
#include <QDebug>
object2::object2(QObject *parent) : QObject(parent)
{
    index_ = 0;
    QTimer *t = new QTimer(this);
    t->setInterval(1000);
    connect(t,&QTimer::timeout,this,[this](){
        iPoint p = new int [1024*1024];
        p[0] = ++index_;
        sigSendPointer(p);
    });
    t->start();
    worker = new QThread();
    worker->setObjectName("object2");
    this->moveToThread(worker);
    worker->start();
}

void object2::onRevMsg(const Message & msg)
{
    qDebug()<<"rev:"<<msg.index;
    delete msg.data;//不删除会有内存泄露
    qDebug()<<"rev thread:"<<QThread::currentThreadId();
}

连接

#include <QCoreApplication>

#include "object1.h"
#include "object2.h"

#include <QThread>
#include <QDebug>



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

    qDebug()<<"Main thread:"<<QThread::currentThreadId();

    object1 *o1 = new object1;
    object2 *o2 = new object2;
    qRegisterMetaType<Message>("Message");//注册
    qRegisterMetaType<iPoint>("iPoint");//注册
    QObject::connect(o1,&object1::sigSendMsg,o2,&object2::onRevMsg);
    QObject::connect(o2,&object2::sigSendPointer,o1,&object1::onRevPointer);

    return a.exec();
}

信号槽中传递自定义数据类型 

Qt编程一个核心亮点就是信号槽机制,通过:

QMetaObject::connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type=Qt::AutoConnection)
进行连接,此处不做详细介绍:

当我们传递一些自定义类型,比如类和结构体的时候,传递可能会出错,自己亲身体会,看到自己的信号槽已经关联了但是信号发出之后根本不会进入槽函数,因为这个信号槽是无效的,因为你自己定义的类型没有注册的话,信号槽机制将无法识别,解决办法就是进行如下操作进行注册

(1)首先包含头文件

#include <QMetaType>

(2)然后注册自自己定义的类型,比如定义结构体stTest

qRegisterMetaType<stTest>("stTest");
(3)进行正常信号槽连接

connect(sender, SIGNAL(sig_test(stTest)), accepter, SLOT(slo_test(stText)));
然后你就会发现信号发出时,槽得到了响应,然后就可以继续在槽函数中对自己传进来的数据进行后续处理了.