Discussion :

[ratus_tara]

Bonjour, étant débutant Qt mon problème vous paraîtra très certainement ridicule mais il me bloque et je n'arrive pas à le résoudre malgré mes nombreuses recherches, je vous explique.

J'aimerais transmettre la valeur d'une variable string entre des slots lors de la pression d'un boutton.

Je vous montre ça sera plus facilement compréhensible

Mon projet a pour nom CourOCR :

Mon Healer nommé CourOCR.h contient simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
#ifndef COUROCR_H
#define COUROCR_H
 
#include <QApplication>
#include <QWidget>
#include <QPushButton>
#include <QMessageBox>
#include <string>
using namespace std;
 
 
class CourOCR : public QWidget
{
    Q_OBJECT
 
    public:
    CourOCR();
    QPushButton *m_bouton;
 
    public slots:
    void reception(string message);
 
};
 
#endif

Mon main.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <QApplication>
#include "courocr.h"
 
 
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
 
    CourOCR fenetre;
    fenetre.show();
 
    return app.exec();
}

et enfin mon CourOCR.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
#include "courocr.h"
 
 
void CourOCR::reception(string message)
{
    if (message == "salut"){
 
        QMessageBox::critical(this, "test", " ok");
 
    } else {
 
        QMessageBox::critical(this, "test", " pas ok");
    }
}
 
 
CourOCR::CourOCR() : QWidget()
{
 
    string message = "salut";
 
    m_bouton = new QPushButton("Transmission", this);
    m_bouton->move(50, 50);
 
// la prochaine ligne représente également mon problème
    QObject::connect(m_bouton, SIGNAL(pressed()), this, SLOT(reception(string)));
 
}

Ici j'ai créé un projet très simple pour vous montrer ma problématique, le but serait que lors de la pression du boutton, la variable "message" envoie sa valeur dans le slot "reception" (ensuite ce slot ce chargera de vérifier la bonne valeur qui lui a été transmise).


Je ne sais pas si cela est compréhensible, n'hésitez surtout pas à me poser des questions si vous n'avez pas bien compris, je remercie tout ceux qui prendront le temps de lire ma problématique et encore plus à ceux qui y répondront.

[koala01]

Salut,

Le plus facile est sans doute d'utiliser la nouvelle syntaxe pour la connection de ton signal au slot correspondant, et d'utiliser une expression labmda pour récupérer le texte.

Cela pourrait se faire sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
connect( m_button, &QPushButton::pressed, this, 
         [&](){
             /* car je présumes que le texte que tu veux transmettre est issus d'un
              *  autre widget...
              */
             auto str = m_texte->texte().toStdString();
             reception(str);
         };);

Il y a cependant une remarque très importante qui doit être faite sur ton code : on n'utiilse JAMAIS la directive using namespace std; et, encore moins dans un fichier d'en-tête!!!

Cette directive a été proposée au tout début de la normalisation du langage, quand il a été décidé de faire passer les fonctionnalités de la bibliothèque standard dans l'espace de noms std. Il y avait déjà à l'époque une base de code écrite en C++ très importante, dont le développement avait été commencé bien avant la normalisation, et le comité a cherché un moyen de faire en sorte que cette base de code continue à compiler avec un minimum de modifications.

La directive using namespace std; a été proposée pour éviter que les développeurs ne doivent se mettre à la recherche de tous les endroits de leur code où ils utilisent des fonctionnalités issues de la bibliothèque standard. En la plaçant intelligemment dans un fichier d'en-tête qui avait "toutes les chances" d'être inclus dans toutes les unités de compilations, il était possible de faire en sorte que le code continue à compiler malgré le fait que la classe string (par exemple) devait désormais être appelée std::string.

Le fait est que l'on ne peut décemment pas dire que le code que tu écrit aujourd'hui ait été développé bien avant la normalisation du langage; sans compter le fait que cette directive pose au final beaucoup plus de problème qu'elle n'en résout. Tu devrais donc prendre l'habitude d'utiliser le nom pleinement qualifié pour toutes les fonctionnalités issues de la bibliothèque standard (par exemple : std::string, std::cout, std::cin, std::vector, ...) .

C'est d'autant plus vrai lorsqu'il s'agit des fichiers d'en-tête, car, tu n'as absolument aucun contrôle sur les endroits du code où un fichier d'en-tête sera inclus au final. La directive using namespace std; risque alors de devenir particulièrement virale, dans le sens où elle s'appliquera à toutes les unités de compilation qui incluent ton fichier d'en-tête, que ce soit de manière directe ou indirecte (ex: un fichier d'ent-ête qui inclut un fichier d'en-tête qui inclut un fichier d'en-tête qui inclut le fichier d'en-tête qui contient la directive), et nombreux sont les développeurs a avoir rencontré quelques problèmes parce qu'ils avaient, justement, développé "quelque part dans leur code" des fonctionnalités dont le nom était identique à celui d'une fonctionnalité issue de la bibliothèque standard .

Enfin, il faut comprendre que le concept d'espaces de noms est de servir de "boites de rangements"; les fonctionnalités que l'on regroupe dans une espace de noms particulier étant -- a priori -- toutes destinées à un usage bien particulier. La directive using namespace <un espace de noms quelconque>; a littéralement pour effet de renverser la boite en question sur la table, et de permettre aux différents outils qu'elle contient de se mélanger avec d'autres outils destinés à des usages tout à fait différents; ce qui complique grandement la tâche lorsqu'il s'agit de choisir l'outil adéquat pour une utilisation particulière

Si tu veux t'éviter des soucis par la suite, suis bien mon conseil, et utilise le nom pleinement qualifié des fonctionnalités issues de la bibliothèque standard

En outre, il faut savoir que les paramètres des fonctions sont -- par défaut -- transmis par copie, et que la copie d'une chaine de caractères est un processus qui prend "énormément de temps", du moins, à l'échelle d'un processeur, qui travaille sur des durées de l'ordre de la microseconde, si pas de l'ordre de la nanoseconde (et qui prend d'autant plus de temps que la chaine de caractères est longue).

Cela n'aura pas énormément d'incidence sur ton programme actuel, mais il faut comprendre que, "ce sont les petits ruisseaux qui font les grands fleuves": si tu copie un nombre suffisant de chaines de caractères pour les transmettre aux différentes fonctions, si ces copies sont suffisamment fréquentes, c'est carrément toute ton application qui risque de souffrir de ralentissements majeurs; et personne n'aime vraiment devoir attendre qu'une application daigne répondre aux actions que l'on entreprend .

L'idéal est donc de prendre l'habitude de transmettre tout ce qui est "plus gros qu'un type primitif" (faisons simple : toutes les classes et toutes les structures que l'on utilise) sous la forme d'une référence, en précisant au besoin que cette référence ne pourra pas être modifiée par la fonction si tel est le cas.

Au final, le prototype de ton slot devrait donc ressembler à quelque chose comme
dans le fichier d'en-tête

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void reception(std::string const & message)

et dans le fichier d'implémentation

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void CourOCR::reception(std::string const & message)

Cela ne mangera pas de pain, et t'évitera bien des soucis par la suite

[ratus_tara]

Salut, deja je te remercie énormément pour le temps que tu m'accordes koala01 et également pour toutes les informations que tu as pu m'accorder (crois moi je ne ferais plus jamais l'erreur du using namespace std; ) tu avais deja eu l'occasion de m'aider indirectement en répondant et en aidant d'autre personne dans ma situation donc tout ça pour dire que j'apprécie vraiment ce que tu fais.

Pour revenir à mon problème, il est parfaitement résolu, au cas où certains voudraient le projet résolu je vous le poste ci-dessous (en espérant n'avoir pas fait d'autres erreurs).

J'ai ajouté un QLineEdit afin d'utiliser cette valeur dans le second slot au lieu du precedent string.


Le CourOCR.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
#ifndef COUROCR_H
#define COUROCR_H
 
#include <QApplication>
#include <QWidget>
#include <QPushButton>
#include <QMessageBox>
#include <QLineEdit>
 
class CourOCR : public QWidget
{
    Q_OBJECT
 
    public:
    CourOCR();
    QPushButton *m_bouton;
    QLineEdit *m_texte;
 
    public slots:
    void reception(std::string const & message);
 
};
 
#endif

Le main.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <QApplication>
#include "courocr.h"
 
 
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
 
    CourOCR fenetre;
    fenetre.show();
 
    return app.exec();
}

Et enfin le CourOCR.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
#include "courocr.h"
 
 
void CourOCR::reception(std::string const & message)
{
    if (message == "salut"){
 
        QMessageBox::critical(this, "test", " ok");
 
    } else {
 
        QMessageBox::critical(this, "test", " pas ok");
    }
}
 
 
CourOCR::CourOCR() : QWidget()
{
 
    std::string message = "salut";
 
    m_bouton = new QPushButton("Transmission", this);
    m_bouton->move(90, 50);
 
    m_texte = new QLineEdit(this);
    m_texte->setGeometry(50, 100, 180, 70);
 
 
    connect( m_bouton, &QPushButton::pressed, this,
             [&](){
 
                 auto str = m_texte->text().toStdString();
                 reception(str);
 
             });
 
}

On peut voir que l'orsque que l'on écrit "salut" dans le QLineEdit et que l'on appuie sur le bouton la QMessageBox affiche bien " ok" et que l'orsque l'on écrit autre chose que "ok" et que l'on appuie sur le bouton la QMessageBox affiche bien " pas ok".

Encore une fois MERCI à ceux qui ont prit le temps de lire mon problème et particulièrement à koala01 pour sa résolution.