Question

I have a QT class instance, called C, (C inherits QOBJECT) that sends a signal S.
In my program, other QT classes instances X are created and destroyed when the program runs. These other classes connect and disconnect S, i.e. they run:

connect(C,SIGNAL(S()), this, SLOT(my_func()));  // <this> is an instance of X

or

disconnect(C,SIGNAL(S()), this, SLOT(my_func()));

In class C, the calculation of whether S should be emitted (and the data associated to it – not shown here) is rather complicated, so I would like the instance of class C (which emits the signal) to be notified when one(or more) object are connected (listening) to S or when all are disconnected.

I have read about the connectNotify and disconnectNotify functions, but their usage is discouraged. Besides the documentation does not state very clearly if there is a one to one relationship between the number of (dis)connectNotify calls and the number of “listener” to the signal (or can one single connectNotify be called for more than one listener?).

Can I just count positively (count++) the number of connectNotify and negatively (count–) the number of disconnectNotify and just react to non-zero value?

Any better way to do this?

Answer 1

First, I think you’ve got it right that connectNotify and disconnectNotify can be used for this purpose – each connect event will be counted properly, even if it is a duplicate from the same object.

You can also double check this with QObject::receivers

int QObject::receivers ( const char * signal ) const [protected]
Returns the number of receivers connected to the signal. Since both
slots and signals can be used as receivers for signals, and the same
connections can be made many times, the number of receivers is the
same as the number of connections made from this signal. When calling
this function, you can use the SIGNAL() macro to pass a specific
signal: if (receivers(SIGNAL(valueChanged(QByteArray))) > 0) {
QByteArray data;
get_the_value(&data); // expensive operation
emit valueChanged(data); } As the code snippet above illustrates, you can use this function to avoid emitting a signal that
nobody listens to. Warning: This function violates the object-oriented
principle of modularity. However, it might be useful when you need to
perform expensive initialization only if something is connected to a
signal.

My suggestion would be to write a simple test program. Override connectNotify and disconnectNotify to increment/decrement a counter, but also use receivers to verify that the counter is correct. Try connecting multiple times, disconnecting multiple times, disconnecting even if there is no connection, etc.

Something to be careful of: connect and disconnect are thread-safe; I’m not sure if the matching Notify functions are safe also.