Virtuel Qt signal?

Tandis que l'examen de certains Qt C++ code je suis tombé sur ceci:

class Foo
{
  Q_OBJECT

signals:
  virtual void someSignal(const QString& str, int n)
  {
    Q_UNUSED(str);
    Q_UNUSED(n);
  }
  ...
};

Maintenant, Qt signaux ne peuvent pas avoir un corps aussi je suis surpris de ce même compile (peut-être parce que le corps est effectivement vide). Aussi, je ne vois pas l'intérêt de faire un signal virtuel ... il ne peut pas avoir un corps aussi comment peut-il être remplacé?

Suis-je manqué quelque chose ou est-ce un code valide odeur?

OriginalL'auteur Rob | 2010-09-08

c++qt

Qui ressemble malodorante pour moi.

C'est valable pour déclarer un signal dans une classe de base et ensuite émettre à partir d'une classe dérivée, par exemple

class MyBase : public QObject
{
    Q_OBJECT
//...
signals:
    void somethingHappened();
};

class MyDerived : public MyBase
{
    Q_OBJECT
//...
    void doSomething();
};

void MyDerived::doSomething()
{
    //....
    emit somethingHappened();
}

Peut-être que c'est ce que la déclaration en question a pour but de réaliser.

OriginalL'auteur Gareth Stockwell

4

C++ parlant, il est normal qu'il compile, étant donné signal est une macro pour protected et Q_UNUSED est une fonte à void.
Mais vous devriez obtenir une erreur lors de l'exécution de moc qui justement crée la mise en œuvre des méthodes déclarées comme des signaux.

Il peut compiler, mais il est encore une ODR de violation: la fonction a deux organismes, l'un dans l'en-tête et une dans le rpc émis par le moc.

OriginalL'auteur gregseth
3

Qt signaux ne sont pas autorisés à être (pur) virtuel. Voir les commentaires à ce bug - https://bugreports.qt.io/browse/QTBUG-41004

OriginalL'auteur gshep
2

TL;DR: je ne sais pas ce que le code était censé faire, mais c'est faux (pas simplement en sentant mal, c'est la preuve prima facie de la non valide). Signal implémentations sont toujours censé être généré par le moc. Le corps du signal doit être supprimé.
1. Pour que le code fonctionne, il doit faire tous les trois: compiler, aller au-delà moc, et lien. Il est vrai que votre code ne compile - le compilateur C++ n'a pas de raison de ne pas. Mais il ne passe pas à travers moc ni lien.
2. Bien que peut-être moc ne détecte pas certains de revenir en 2010, voici comment moc actes d'aujourd'hui:
  
  a) moc ne permet pas de signal de définitions de classe d'entités, avec le diagnostic Error: Not a signal declaration. Donc class X { Q_SIGNAL void s() {} }; qui la déclenche, mais class X { Q_SIGNAL void s(); }; void X::s() {} ne sera pas.
  
  b) moc ne permettent pas à une Q_OBJECT macro pas à une classe dérivant de QObject, avec le diagnostic Error: Class contains Q_OBJECT macro but does not inherit from QObject.
3. Car il ne ferait aucun sens de parler de signaux dans les classes qui ne découle pas d' QObject, supposons que le code a vraiment regardé comme suit:
```
class Foo : public QObject
{
  Q_OBJECT
signals:
  virtual void someSignal(const QString&, int);
};
void Foo::someSignal(const QString& str, int n)
{
  Q_UNUSED(str);
  Q_UNUSED(n);
}
```
  Cela s'est passé moc et de compiler, mais il ne sera pas le lien. L'éditeur de liens émettre un diagnostic pour de multiples déclaration de Foo::someSignal. Il y a une définition dans ce fichier, et l'autre dans la moc-source généré.
OriginalL'auteur Kuba Ober

Vous devez vous connecter pour publier un commentaire.