Question sur les slots Qt et les appels multiples

Question

Je suis en train d'apprendre Qt et j'ai une question très simple.

S'il existe une variable (fonction de portée) dans un emplacement et que l'emplacement est appelé plusieurs fois, chaque fois avant le dernier appel (est-ce encore possible?), La variable sera-t-elle écrasée? Dans le sens où, si l'emplacement est appelé avant que l'exécution précédente ne soit retournée, cela ne causerait-il pas des erreurs?

Merci.

Answer 1

Si vous utilisez vraiment des variables d'étendue de fonction, cela ne devrait pas avoir d'importance. Exemple:

class WheelSpinner : public QThread 
{ 
Q_OBJECT; 
public: 
    WheelSpinner(QObject* receiver, const char* slot) 
    { 
     connect(this, SIGNAL(valueChanged(int)), receiver, slot, 
       Qt::DirectConnect); 
    } 

    void run() 
    { 
     for (int i = 0; i < 100000; ++i) 
     { 
      emit (valueChanged(i)); 
     } 
    } 

public signals: 
    void valueChanged(int value); 
}; 

class ProgressTracker : public QObject 
{ 
Q_OBJECT; 
public: 
    ProgressTracker() { } 

public slots: 
    void updateProgress(int value) 
    { 
     // While in this function, "value" will always be the proper 
     // value corresponding to the signal that was emitted. 
     if (value == 100000) 
     { 
      // This will cause us to quit when the *first thread* that 
      // emits valueChanged with the value of 100000 gets to this point. 
      // Of course, other threads may get to this point also before the 
      // program manages to quit. 
      QApplication::quit(); 
     } 
    } 
}; 

int main(int argc, char **argv) 
{ 
    QApplication app(argc, argv); 
    ProgressTracker tracker; 
    WheelSpinner spinner1(&tracker, SLOT(updateProgress(int ))); 
    WheelSpinner spinner2(&tracker, SLOT(updateProgress(int ))); 
    WheelSpinner spinner3(&tracker, SLOT(updateProgress(int ))); 

    spinner1.run(); 
    spinner2.run(); 
    spinner3.run(); 

    return (app.exec()); 
} 

Answer 2

Oui si les appels proviennent de différents threads ET que vous utilisez une connexion directe. Si vous utilisez des connexions en file d'attente, les appels d'emplacement seront exécutés l'un après l'autre sur la boucle d'événements qui est exécutée sur le thread auquel appartient votre objet récepteur. (éditez grâce au commentaire d'Idan K).

Checkout Signal and slots la connexion en attente ou QMutexLocker pour résoudre votre problème.

Answer 3

Tant que la fonction est reentrant il n'y a pas de problème.