Segnale Qt virtuale?

Question

mentre la revisione di un codice C++ Qt mi sono imbattuto in questo:

class Foo 
{ 
    Q_OBJECT 

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

Ora, segnali Qt non possono avere un corpo così Mi sorprende questo ancora compilazione (forse perché il corpo è effettivamente vuoto). Inoltre, non vedo il punto di rendere virtuale un segnale come ... non può avere un corpo quindi come può essere ignorato?

Mi manca qualcosa qui o si tratta di un odore di codice valido?

Answer 1

Mi sembra maleodorante.

È valido dichiarare un segnale in una classe base e quindi emetterlo da una classe derivata, ad es.

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

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

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

Forse questo è ciò che la dichiarazione nella domanda era destinata a raggiungere.

Answer 2

A rigor di C++ parlando è normale che compila, data signal è una macro per protected e Q_UNUSED è un cast di void. Ma si dovrebbe ottenere un errore durante l'esecuzione di moc che crea esattamente l'implementazione dei metodi dichiarati come segnali.

Answer 3

I segnali Qt non possono essere (puri) virtuali. Vedi i commenti a questo bug - https://bugreports.qt.io/browse/QTBUG-41004

Answer 4

TL; DR: Non so che cosa il codice era destinato a fare, ma è sbagliato (non solo ha un cattivo odore, è prima facie non valido). Le implementazioni del segnale sono sempre destinate a essere generate da moc. Il corpo del segnale dovrebbe essere rimosso.

1. Per il codice per lavorare, deve fare tutte e tre: la compilazione, get moc passato e collegamento. È vero che il tuo codice è compilato - il compilatore C++ non ha motivo di non farlo. Ma non passerà attraverso Moc né collegherà.

2. Anche se forse moc non ha rilevato alcune indietro nel 2010, ecco come moc atti oggi:

   a) moc non consente definizioni dei segnali negli organi di classe, con la diagnostica Error: Not a signal declaration. Quindi lo class X { Q_SIGNAL void s() {} }; lo innesca, ma non lo è il class X { Q_SIGNAL void s(); }; void X::s() {}.

   b) moc non consente una macro Q_OBJECT in una classe non derivanti da QObject, con la diagnostica Error: Class contains Q_OBJECT macro but does not inherit from QObject.

3. Dal momento che non ha alcun senso parlare di segnali di classi che non derivano da QObject, supponiamo che il codice sembrava davvero come segue:

   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); 
   } 
   

   Ciò superare moc e compilerà, ma non collegherà. Il linker invierà una diagnostica per la dichiarazione multipla di Foo::someSignal. C'è una definizione in questo file e un'altra nella sorgente generata dal moc.