QT establish signal slots between different classes and transfer parameters

Qt List of articles

Preface

Recently encountered this situation ： Suppose there is 3 Classes ：A,B,C
A Classes and B Passing data between classes , and C Class is responsible for controlling A Classes and B class , let me put it another way ,C Class management A Classes and B class .
Qt Establish signal slots between different classes , And pass the parameters

One .A class ：TestA

1. Header file and implementation file

#ifndef TESTA_H
#define TESTA_H

#include <QObject>

class TestA : public QObject
{
    
    Q_OBJECT
public:
    explicit TestA(QObject *parent = nullptr);
    void emitDataFromTestA();

signals:
    void sendDataFromTestA(const char* data);
public slots:
    void recvDataAtTestA(const char* data);
    
};

#endif // TESTA_H


```cpp
#include "TestA.h"
#include <QDebug>

TestA::TestA(QObject *parent) : QObject(parent)
{
    

}

void TestA::emitDataFromTestA()
{
    
    const char* name = "Data from testA";
    emit sendDataFromTestA(name);
}

void TestA::recvDataAtTestA(const char *data)
{
    
// QString print = data;
// qDebug() << print.toLatin1();
    qDebug() << "TestA class recive data:" << data;
}

#  Two 、B class ：TestB

```cpp
#ifndef TESTB_H
#define TESTB_H

#include <QObject>

class TestB : public QObject
{
    Q_OBJECT
public:
    explicit TestB(QObject *parent = nullptr);
    void emitDataFromTestB();
signals:
    void sendDataFromTestB(const char* data);
public slots:
    void recvDataAtTestB(const char* data);
    
};

#endif // TESTB_H

#include "TestB.h"
#include <QDebug>

TestB::TestB(QObject *parent) : QObject(parent)
{
    

}

void TestB::emitDataFromTestB()
{
    
    const char* name = "Data from testB";
    emit sendDataFromTestB(name);

}

void TestB::recvDataAtTestB(const char *data)
{
    
    qDebug() << "TestB class recive data:" << data;
}

3、 ... and C class ： control A and B Class

#ifndef CONTROL_H
#define CONTROL_H

#include <QObject>
#include "TestA.h"
#include "TestB.h"

class Control : public QObject
{
    
    Q_OBJECT
public:
    explicit Control(QObject *parent = nullptr);
    ~Control();

public:
    TestA* m_pTestA;
    TestB* m_pTestB;

    void controlSendData();

signals:

};

#endif // CONTROL_H

#include "Control.h"

Control::Control(QObject *parent) : QObject(parent)
{
    
    m_pTestA = new TestA;
    m_pTestB = new TestB;

    QObject::connect(m_pTestA, &TestA::sendDataFromTestA, m_pTestB, &TestB::recvDataAtTestB);
    QObject::connect(m_pTestB, &TestB::sendDataFromTestB, m_pTestA, &TestA::recvDataAtTestA);
}

Control::~Control()
{
    
    if(m_pTestA)
    {
    
        delete  m_pTestA;
        m_pTestA = nullptr;
    }
    if(m_pTestB)
    {
    
        delete m_pTestB;
        m_pTestB = nullptr;
    }
}

void Control::controlSendData()
{
    
    m_pTestA->emitDataFromTestA();
    m_pTestB->emitDataFromTestB();
}

Four Calling class

#include "MainWindow.h"
#include "TestA.h"
#include "TestB.h"
#include "Control.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    
    QApplication a(argc, argv);
// TestA testA;
// TestB testB;
// a.connect(&testA, &TestA::sendDataFromTestA, &testB, &TestB::recvDataAtTestB);
// testA.emitDataFromTestA();

// a.connect(&testB, &TestB::sendDataFromTestB, &testA, &TestA::recvDataAtTestA);
// testB.emitDataFromTestB();
    Control control;
    control.controlSendData();

    MainWindow w;
    w.show();
    return a.exec();
}

function

Source download

Source download