How we can connect the signals and slot with diffe

Question

In Qt, signals and slots require matching argument types:

QObject::connect: Incompatible sender/receiver arguments QLabel::linkActivated(QString) --> Button::call(int)

How can I implement a combination like this?

Answer 1

A simple method is to have an intermediate slot that calls the slot that you want. e.g.

connect(src, SIGNAL(linkActivated(QString)), this, SLOT(receiveLink(QString)));

and then

void receiveLink(QString blah)
{
  int response = someFunction(blah);
  mybutton->call(response);
}

You have to define some way to interpret the string into an int.

Answer 2

From the signals slots documentation:

The signature of a signal must match the signature of the receiving slot. (In fact a slot may have a shorter signature than the signal it receives because it can ignore extra arguments.)

This means that a signal of the form

signal(int, int, QString)

can only be connected with slots with the following signatures

slot1(int, int, QString)
slot2(int, int)
slot3(int)
slot4()

As koan suggests the best approach is to use another slot with a QString argument and then call the slot you actually want.

Answer 3

Default values for slot parameters helps very well. This allow to connect signals with different signatures to slot (vice versa to @pnezis answer):

private slots:
  void slot( int x = 10, int y = 20, QString text = QString() );

may be connected to different signals:

signal1(int, int, QString)
signal2(int, int)
signal3(int)
signal4()

---

Also Qt 4.8 suggest useful QSignalMapper class:

This class collects a set of parameterless signals, and re-emits them with integer, string or widget parameters corresponding to the object that sent the signal.

But only for one parameter:

QSignalMapper* mapper = new QSignalMapper(this) ;

connect(action, SIGNAL(triggered()), mapper, SLOT(map())) ;
mapper->setMapping(action, "param value") ;

connect(mapper, SIGNAL(mapped(const QString &)),
  this, SIGNAL(clicked(const QString &)));

Answer 4

As a complementary answer, if you don't want to write an intermediate slot, you can use the lambda expressions (of course with C++11 support) to invoke the method. However, the connector class must know the parameter types used in those particular signals and slots.

To give an example, assuming that you're trying to connect a signal with a parameter type of QString to a slot with a parameter type of char, you can do it like this;

class SignalClass{
signals:
    void testSignal(QString tString);
};

class SlotClass{
public slots:
    void testSlot(char tChar);
};

class ConnectorClass{
public:
    void connectSignalAndSlot () {
        SignalClass tSigClass;
        SlotClass tSlotClass;
        connect(&tSigClass, &SignalClass::testSignal,
                [=](QString tString) { this->metaObject()->invokeMethod(tSlotClass,"testSlot", Q_ARG(char, tString.at(0).toLatin1())) }
        );
    }
}

Kinda ugly stuff, but does the job.

• No coupled classes
• No intermediate connector functions