Qt: signification de la valeur de retour de l'emplacement?

Question

Selon la documentation, la valeur de retour d'un emplacement ne signifie rien.
Pourtant, dans le code moc généré, je vois que si un slot retourne une valeur, cette valeur est utilisée pour quelque chose. Une idée de ce que ça fait?

---

Voici un exemple de ce dont je parle. ceci est pris du code généré par moc. 'message' est un emplacement qui ne retourne rien et 'selectPart' est déclaré comme retournant int.

case 7: message((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break; 
case 8: { int _r = selectPart((*reinterpret_cast< AppObject*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); 
    if (_a[0]) *reinterpret_cast< int*>(_a[0]) = _r; } break; 

Answer 1

En regardant à travers la source Qt, il semble que lorsqu'une fente est appelée à partir QMetaObject :: InvokeMethod le type de retour peut être spécifié et la valeur de rendement obtenu. (Jetez un oeil à invokeMethod dans l'aide de Qt)

Je n'ai pas trouvé beaucoup d'exemples de ce qui est réellement utilisé dans la source Qt. Un que j'ai trouvé

bool QAbstractItemDelegate::helpEvent 

qui est une fente avec un type de retour et est appelé à partir

QAbstractItemView::viewportEvent 

utilisant invokeMethod.

Je pense que la valeur de retour pour un emplacement n'est disponible que lorsque la fonction est appelée directement (lorsqu'il s'agit d'une fonction C++ normale) ou lors de l'utilisation de invokeMethod. Je pense que cela est vraiment fait pour les fonctions Qt internes plutôt que pour une utilisation normale dans les programmes utilisant Qt.

Edit: Pour le cas de l'échantillon:

case 8: { int _r = selectPart((*reinterpret_cast< AppObject*(*)>(_a[1])), *reinterpret_cast< int(*)>(_a[2]))); 
if (_a[0]) *reinterpret_cast< int*>(_a[0]) = _r; } break; 

le vecteur _A est une liste d'arguments qui est passé à qt_metacall. Ceci est passé par QMetaObject :: invokeMethod. Ainsi, la valeur de retour dans le code généré par moc est enregistrée et renvoyée à l'appelant. Donc, pour les interactions normales entre fentes et signaux, la valeur de retour n'est utilisée pour rien du tout. Cependant, le mécanisme existe pour que les valeurs de retour des emplacements soient accessibles si l'emplacement est appelé via invokeMethod.

Answer 2

La valeur de retour est utile uniquement si vous voulez appeler la fente en fonction de membre normal:

class MyClass : public QObject { 
    Q_OBJECT 
public: 
    MyClass(QObject* parent); 
    void Something(); 
public Q_SLOTS: 
    int Other(); 
};
 

void MyClass::Something() { int res = this->Other(); ... } 

Edit: Il semble que ce n'est pas la seule façon dont la valeur de retour peut être utilisé, la méthode QMetaObject :: invokeMethod peut être utilisé pour appeler un slot et obtenir une valeur de retour. Bien qu'il semble que c'est un peu plus compliqué à faire.

Answer 3

Il est très utile lorsque vous traitez avec un langage dynamique tel qtPython qtscript JavaScript et ainsi de suite. Avec ce langage/bindings, vous pouvez utiliser C++ QObject en utilisant l'interface fournie par MetaObject. Comme vous le savez probablement, seuls les signaux et les slots sont analysés par moc et génèrent une description de MetaObject. Donc, si vous utilisez un QObject C++ à partir d'une liaison javascript, vous ne pourrez appeler que des slots et vous aurez besoin de la valeur de retour. Souvent, les liaisons Qt pour les langages dynamiques offrent une certaine facilité d'accès à la méthode normale, mais le processus est définitivement plus trépidant.

Answer 4

Tous les emplacements sont exposés dans QMetaObject, où l'accès à l'objet s'effectue via une interface réfléchissante. Par exemple, QMetaObject::invokeMethod() prend un paramètre QGenericReturnArgument. Donc, je crois que ce n'est pas pour l'utilisation explicite des machines à sous, mais plutôt pour l'invocation dynamique des méthodes en général. (Il existe d'autres façons d'exposer les méthodes à QMetaObject que de les transformer en emplacements.La fonction invokeMethod est par exemple utilisée par divers langages dynamiques tels que QML et Javascript pour appeler les méthodes QObject:s. (Il y a aussi un pont Python-Qt appelé PythonQt qui utilise. A ne pas confondre avec PyQt, qui est une enveloppe complète.)

La valeur de retour est utilisé pour faire des appels syncrhonous dans les threads dans une application Qt (pris en charge par invokeMethod et le type de connexion de réglage à Qt::BlockingQueuedConnection, qui a les documents suivants:

Identique à QueuedConnection, à l'exception des blocs de thread courant jusqu'à ce que le retour à sous Ce type de connexion ne doit être utilisé lorsque l'émetteur et le récepteur sont. dans différents threads. Remarque: La violation de cette règle peut entraîner l'interblocage de votre application .