QT signal and slot communication mechanism (when multiple windows communicate back and forth [parent and child windows])

This article aims to share technology

Doing it qt Under development , It is inevitable to encounter such problems . The parent class triggers an event , It needs to be sent to subclasses .
You know how to use the signal slot at this time , Binding events , Can .
Suppose a situation
A yes B Parent window of ,B yes C Parent window of ,C yes D Parent window of .
Then I want to A Send your message to D.
There is a practice at this time .
That is to say First the A Signals and B Slot binding for . stay B Triggered in the slot function of C The signal of . Finally by C Send a signal to D.
Although this approach is feasible , But it's too complicated .
The key is coming.
If you want to achieve A Can directly and D signal communication .
You need to implement a global singleton class (AppEvent). stay A Class defines the signal ( hypothesis a The signal is sSendTest), And then again appevent Common signals are defined in ( Assuming that sSendPubliceTest), take a The signal of is bound to appevent The signal of , And then D Bound to the appevent Corresponding slot function
How to write it ：

connect(this,&A::sSendTest,AppEvent::getInstance(),&AppEvent::sSendPublicTest); //A Sending signal   Written in A in 
connect(AppEvent::getInstance(),&AppEvent::sSendPublicTest,this,&D::ReceiverTest);  //D Receive and process signals , Written in D in 

ok, The complete code is as follows .

widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include "appevent.h"
#include <QLabel>
#include <qdebug.h>

class Widget : public QWidget
{
    
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

protected slots:
    void onBtnClicked();


signals:
    void sSendTest();
};


class testwgt : public QLabel
{
    
    Q_OBJECT
public:
    explicit testwgt(QWidget *parent = nullptr)
    {
    
        connect(AppEvent::getInstance(),&AppEvent::sSendTest,this,&testwgt::ReceiverTest);
    };
    ~testwgt(){
    };

protected slots:
    void ReceiverTest()
    {
    
        qDebug()<<"23456";
    };

signals:

};

#endif // WIDGET_H

widget.cpp

#include "widget.h"
#include <qdebug.h>
#include <QPushButton>
#include <QVBoxLayout>
#include "appevent.h"
Widget::Widget(QWidget *parent)
    : QWidget(parent)
{
    
    this->resize(800,600);
    connect(this,&Widget::sSendTest,AppEvent::getInstance(),&AppEvent::sSendTest);  // Signals can trigger signals 

    testwgt *wgt=new testwgt(this);
    wgt->setFixedSize(100,100);
    wgt->setStyleSheet("background:green");

    QPushButton *btn=new QPushButton(tr("Abc"),this);
    connect(btn,&QPushButton::clicked,this,&Widget::onBtnClicked);

    QVBoxLayout *mainLayout=new QVBoxLayout(this);
    mainLayout->addWidget(btn);
    mainLayout->addWidget(wgt);
    mainLayout->setMargin(0);
    this->setLayout(mainLayout);




}

Widget::~Widget()
{
    
}

void Widget::onBtnClicked()
{
    
    emit sSendTest();
}

appevent.h

#ifndef APPEVENT_H
#define APPEVENT_H

#include <QObject>
#include <QMutex>
#include <QSharedPointer>

class AppEvent : public QObject
{
    
    Q_OBJECT
public:
    static AppEvent *getInstance();
private:
    explicit AppEvent(QObject *parent = nullptr);
    AppEvent& operator =(AppEvent&) = delete;
    AppEvent(AppEvent&) = delete;

private:
    static AppEvent *m_appEvent_ptr;
    static QMutex m_mutex;

protected slots:

signals:
    void sSendTest();

};

#endif // APPEVENT_H

appevent.cpp

#include "appevent.h"
#include <qdebug.h>
AppEvent *AppEvent::m_appEvent_ptr=nullptr;
QMutex AppEvent::m_mutex;
AppEvent *AppEvent::getInstance()
{
    
    if (nullptr == m_appEvent_ptr){
    
        m_mutex.lock();
        if (nullptr == m_appEvent_ptr){
    
            m_appEvent_ptr = new AppEvent;
        }
        m_mutex.unlock();
    }
    return m_appEvent_ptr;
}
AppEvent::AppEvent(QObject *parent) : QObject(parent)
{
    
}

A picture of the day