Qt 中的信号/插槽向量？

Question

First some background as to why I am trying to do this: I have a class, say MasterClass which is a subclass of QWidget , that creates multiple new QObject derived class object, say SlaveClass , this happens dynamically during runtime. The new SlaveClass is moved to a new QThread by using moveToThread because it has to do long-running computations and I do not want my GUI to freeze. Since the SlaveClass is in a different thread, the proper way for me to invoke any method in the SlaveClass is by using Qt's Signal/Slot mechanism along with Qt::QueuedConnection . The SlaveClass has many signals and slots which I want to connect to my MasterClass. What I am trying to do is to create a QVector of signals and slots in my MasterClass so that I can add and remove from it dynamically and connect and disconnect these to my SlaveClass depending on if the SlaveClass is being created or destroyed.

To test out my theory I created a MasterClass and tried to create vectors of signals and slots inside it and tried connecting the signals to slots to see if it works:

First try [doesn't work]:

masterclass.h

#include <QWidget>
#include <QVector>
#include <QDebug>
#include <functional>

Class MasterClass : public QWidget
{
    Q_OBJECT

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

signals:
    void sig_test(int testID);
    QVector<std::function<void(int)>> vSig;

private slots:
    void slt_test(int testID);
    QVector<std::function<void(int)>> vSlt;
};

masterclass.cpp

#include "masterclass.h"

MasterClass::MasterClass(QWidget *parent)
    : QWidget(parent)
{
    vSig << [this](int id) -> void{return this->sig_test(id); };
    vSig << [this](int id) -> void{return this->sig_test(id); };
    vSig << [this](int id) -> void{return this->sig_test(id); };

    vSlt << [this](int id) -> void{return this->slt_test(id); };
    vSlt << [this](int id) -> void{return this->slt_test(id); };
    vSlt << [this](int id) -> void{return this->slt_test(id); };

    connect(this, &MasterClass::vSig[0], this, &MasterClass::vSlt[0]);
    connect(this, &MasterClass::vSig[1], this, &MasterClass::vSlt[1]);
    connect(this, &MasterClass::vSig[2], this, &MasterClass::vSlt[2]);

    emit vSig[0](78);
    emit vSig[1](68);
    emit vSig[2](58);
}

void MasterClass::slt_test(int testID)
{
    qDebug() << "\n" << testID << "\n";
}

This gives 2 errors:

1. E0304: no instance of overloaded function "MasterClass::connect" matches the argument list
2. MSB4181: The "QtRunWork" task returned false but did not log an error.

The error no.2 above is because I am declaring QVector<std::function<void(int)>> vSig; under signals: and QVector<std::function<void(int)>> vSlt; under private slots: . This error goes away as soon as I move the above two vectors under private: .

Second Try [works, but only kind of]:

masterclass.h

.
.
.

signals:
    void sig_test(int testID);

private slots:
    void slt_test(int testID);

private:
    QVector<std::function<void(int)>> vSig;
    QVector<std::function<void(int)>> vSlt;
};

masterclass.cpp

.
.
.
    vSig << [this](int id) -> void{return this->sig_test(id); };
    vSig << [this](int id) -> void{return this->sig_test(id + 1); }; // Notice change in argument
    vSig << [this](int id) -> void{return this->sig_test(id + 2); }; // Notice change in argument

    vSlt << [this](int id) -> void{return this->slt_test(id); };
    vSlt << [this](int id) -> void{return this->slt_test(id + 10); }; // Notice change in argument
    vSlt << [this](int id) -> void{return this->slt_test(id + 20); }; // Notice change in argument

    connect(this, &MasterClass::sig_test, this, &MasterClass::slt_test);

    emit vSig[0](78);
    emit vSig[1](68);
    emit vSig[2](58);
}

void MasterClass::slt_test(int testID)
{
    qDebug() << "\n" << testID << "\n";
}

This works and prints: 78 69 60

There are two things to note here:

1. If I remove the connect(this, &MasterClass::sig_test, this, &MasterClass::slt_test); line, it prints nothing.
2. Notice the change in the arguments when creating the vSig and vSlt vectors. From the output, I can see that the correct vSig is being called as it adds 1 to the argument of the second vSig function and adds 2 to the argument of the third vSig function. However, it doesn't add 10 to the argument of the second vSlt function or 20 to the argument of the third vSlt function, this makes me wonder if it is calling the correct vSlt function or is it just calling slt_test() function?

Is there any way I can improve this?

When creating SlaveClass objects dynamically, I would have to do something like this to connect to it's slots connect(MasterClassPointer, &MasterClass::vSig[id], SlaveClassPointer, &SlaveClass::slotName); . Is it possible?

PS I know I can use QMetaObject::invokeMethod() function but I would like to avoid it if possible.

Answer 1

You can have a vector of slots (a lambda function can be a slot), but you can't really have a vector of signals. However, you can have your signal connected to something that dispatches to the correct slot based on ID:

// MasterClass.h
class MasterClass : public QObject {
// ... class stuff ...

signals:
  void masterSignal(int id);

private:
std::unordered_map<int, SlaveClass*> m_slaveMap;

}

// MasterClass.cpp ...
connect(this, &MasterClass::masterSignal, slavePtr,
  [](int id) { m_slaveMap[id]->slot(); });

The other option is to just filter out calls with the wrong ID on the slave slot:

int slaveID = /*something*/
connect(masterPtr, &MasterClass::masterSignal, slavePtr,
  [myID = slaveID, slavePtr] (int id) { if (myID == id) slavePtr->slot(); });