Déconnexion / reconnexion impossible avec Arduino

**poezadri** · 19/09/2019, 20h03

Bonjour je viens vers vous car j'ai un petit problème je développe un premier programme avec Qt et lors de mes test je m'aperçoit que si je déconnecte mon Arduino avec port->close() il m'est impossible de me reconnecter par la suite sauf si je débranche la carte et rebranche ou en relançant le programme,
la fonction write() me retourne QIODevice::write (QSerialPort): device not open
auriez vous des solutions?
à noter que pour la connexion je me suis inspiré de ce tuto, que l'envoi de donnée fonctionne

http://tvaira.free.fr/projets/activi...ts-disponibles

merci d'avance

**poezadri** · 20/09/2019, 18h13

peut être que le code vous aidera à m'aidez un peu plus, petit probleme de plus quand je change de couleur
avec la palette je peux envoyer le changement de couleur mais qu'une seul fois

generalsetting.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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
#include "generalsetting.h"
 
#include<QDebug>
 
generalsetting::generalsetting()
{
    setWindowTitle("Réglage Table");
 
 
    // 1 : Créer le QTabWidget
       QTabWidget *onglets = new QTabWidget(this);
       onglets->setGeometry(30, 20, 500, 300);
 
       // 2 : Créer les pages, en utilisant un widget parent pour contenir chacune des pages
       QWidget *page1 = new QWidget;
       QWidget *page2 = new QWidget;
       QLabel *page3 = new QLabel; // Comme un QLabel est aussi un QWidget (il en hérite), on peut aussi s'en servir de page
        QLabel *labelbaud = new QLabel("Baudrates:");
        QLabel *labelport= new QLabel("Port:");
       // 3 : Créer le contenu des page de widgets
 
           // Page 1
 
 
           listebaud = new QComboBox(this);
           listebaud->addItem("9600");
           listebaud->addItem("19200");
           listebaud->addItem("38400");
           listebaud->addItem("57600");
           listebaud->addItem("74880");
           listebaud->addItem("115200");
           listebaud->addItem("230400");
           listebaud->addItem("250000");
           listebaud->addItem("500000");
           listebaud->addItem("1000000");
           listebaud->addItem("2000000");
 
 
           QVBoxLayout *vbox1 = new QVBoxLayout;
            QHBoxLayout *Hbox1a = new QHBoxLayout;
            QHBoxLayout *Hbox1b = new QHBoxLayout;
            QHBoxLayout *Hbox1c = new QHBoxLayout;
 
            page1->setLayout(vbox1);
             vbox1->addLayout(Hbox1a);
              vbox1->addLayout(Hbox1b);
              vbox1->addLayout(Hbox1c);
 
              listeport = new QComboBox(this);
 
              buttonok = new QPushButton("Connection",this);
              buttonok->setEnabled(false);
 
 
              QWidget::connect(listeport, SIGNAL(currentIndexChanged(int)), this, SLOT(Degriser(int)));
               QWidget::connect(buttonok, SIGNAL(clicked()), this, SLOT(connectionArduino()));
 
 
 
 
             QPushButton *boutonannuler = new QPushButton("Annuler");
 
 
            Hbox1c->addWidget(buttonok);
            Hbox1c->addWidget(boutonannuler);
            Hbox1a->addWidget(labelbaud);
            Hbox1a->addWidget(listebaud);
            Hbox1b->addWidget(labelport);
            Hbox1b->addWidget(listeport);
 
 
     QObject::connect(boutonannuler, SIGNAL(clicked()),this, SLOT(reject()));
 
 
           // Page 2
 
           QProgressBar *progress = new QProgressBar;
           progress->setValue(50);
           QSlider *slider = new QSlider(Qt::Horizontal);
           QPushButton *bouton3 = new QPushButton("Valider");
 
           QVBoxLayout *vbox2 = new QVBoxLayout;
           vbox2->addWidget(progress);
           vbox2->addWidget(slider);
           vbox2->addWidget(bouton3);
 
           page2->setLayout(vbox2);
 
           // Page 3 (je ne vais afficher qu'une image ici, pas besoin de layout)
 
           page3->setPixmap(QPixmap("icone.png"));
           page3->setAlignment(Qt::AlignCenter);
 
       // 4 : ajouter les onglets au QTabWidget, en indiquant la page qu'ils contiennent
       onglets->addTab(page1, "Connexion Arduino");
       onglets->addTab(page2, "Télécommande");
       onglets->addTab(page3, "About");
 
}
 
 
void generalsetting::connectionArduino()
{
    if ((currentport != "Selection du port")&& (etatconnection != "Connect"))
    {
        QString string(listebaud->currentText());
         bool ok = false;
        int nombre = string.toInt(&ok, 10);
        if( ok ){
            qDebug()<<"Nombre vaut :" << nombre;
            qDebug()<<"Erreur"<<nombre;
     }
 
      else
           {
            qDebug()<<"Erreur";
          }
        accesport = new QSerialPort(currentport);
        accesport->open(QIODevice::ReadWrite);
        accesport->setBaudRate(nombre);
        accesport->setDataBits(QSerialPort::Data8);
        accesport->setParity(QSerialPort::NoParity);
        accesport->setStopBits(QSerialPort::OneStop);
        accesport->setFlowControl(QSerialPort::NoFlowControl);
 
        buttonok->setText("Déconnection");
        etatconnection = "Connect";
        listeport->setEnabled(false);
        listebaud->setEnabled(false);
        QMessageBox::information(this, "Connection Réussi", "Vous êtes connecté");
         etatport=1;
 
 
 
    }
   else if (etatconnection == "Connect")
    {
            accesport = new QSerialPort(currentport);
            emit accesport->aboutToClose();
            accesport->close();
            qDebug("<debug> etat ouverture port : %d", accesport->isOpen());
            delete accesport;
            etatconnection = "Deconnect";
             buttonok->setText("Connection");
             listeport->setEnabled(true);
             listebaud->setEnabled(true);
            QMessageBox::information(this, "Déconnection Réussi", "Vous êtes déconnecté");
            etatport=0;
    }
    else
    {
          QMessageBox::information(this, "Connection Impossible", "Un problème empèche la connection");
    }
 
}
 
void generalsetting::Degriser(int signalgriser)
{
   if(etatport==0)
    {
        if (signalgriser == 0)
            {
             if(etatport==0)
                {
                     buttonok->setEnabled(false);
                 }
             currentport = (listeport->currentText());
 
             }
        else
             {
                buttonok->setEnabled(true);
                currentport = (listeport->currentText());
              }
    }
}
void generalsetting::errorconnection()
{
    qDebug()<< accesport;
}
 
void generalsetting::actualise_port()
{
    if (etatport==0)
    {
            qDebug() <<"cocuou";
           for (int i=oldliste; i > 0;i--)
            {
                listeport->removeItem(i);
            }
 
        listeport->removeItem(0);
        QList<QSerialPortInfo> listePorts;
        QStringList listePortsDisponibles;
        listeport->addItem("Selection du port");
        listePorts = QSerialPortInfo::availablePorts();
        for (int i=0; i < listePorts.size();i++)
        {
          QSerialPortInfo info = listePorts.at(i);
          {
                listePortsDisponibles << info.portName();
                listeport->addItem(info.portName());
          }
        }
      oldliste=listePorts.size();
    }
 
}
 
void generalsetting::envoiArduinoaperio(int)
{
    if(etatport==0)
    {
        QMessageBox::information(this, "Pas de Connexion", "Vous n'êtes pas connecté");
    }
    else
    {
        // instancie un objet QTimer
       timer = new QTimer(this);
 
        // connecte le signal timeout() au slot envoyer()
        connect(timer, SIGNAL(timeout()), this, SLOT(envoyer()));
 
        // démarre le timer (la période s'expime en millisecondes)
        timer->start(10000); // toutes les secondes
 
        // ...
 
        // arrête le timer
        if(timer->isActive())
        {
            timer->stop();
        }
 
    }
 
}
void generalsetting::emettrearduino(QString trame)
{
    int nombresOctets = -1;
 
    if (accesport == nullptr || etatport==0)
    {
        QMessageBox::information(this, "Pas de Connexion", "Vous n'êtes pas connecté");
        return;
    }
 
    nombresOctets = accesport->write(trame.toLocal8Bit());
 
    qDebug() << "coucou c'ets moi"<<nombresOctets;
}

generalsetting.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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#ifndef generalsetting_H
#define generalsetting_H
 
#include <QDialog>
#include<QTabWidget>
#include<QLabel>
#include<QLineEdit>
#include<QVBoxLayout>
#include<QProgressBar>
#include<QSlider>
#include<QPushButton>
#include<QComboBox>
#include<QString>
#include<QSerialPortInfo>
#include<QDebug>
#include<QSerialPort>
#include<QStateMachine>
#include<QEventTransition>
#include<QMessageBox>
#include<QTimer>
 
class generalsetting: public QDialog
{
       Q_OBJECT
 
public:
    generalsetting();
 
private:
    QString currentport;
 QSerialPort *accesport;
  QString *port;
  QComboBox *listeport;
  QPushButton *buttonok;
    QString etatconnection ;
    QComboBox *listebaud;
    QList<QSerialPortInfo> *listePorts;
    QStringList * listePortsDisponibles;
     QTimer *timer;
 
    int liste=0;
    int oldliste=0;
    int etatport=0;
 
public slots:
    void connectionArduino();
    void Degriser(int);
    void errorconnection();
    void actualise_port();
    void envoiArduinoaperio(int);
void emettrearduino(QString);
};
 
#endif // SETTING__H

Buttonledpalette.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
#include "buttonledpalette.h"
#include"generalsetting.h"
button_ledpalette::button_ledpalette(QWidget *parent)
    :QPushButton(parent)
{
 
   setText("Changer Couleur des LEDs");
   setCursor(Qt::PointingHandCursor);
 
}
 
void button_ledpalette::envoiebutton()
{
 
}
 
void button_ledpalette::paletteopen()
{
    QColor couleur = QColorDialog::getColor(Qt::white);
    QPalette palette;
   choicecouleur = couleur.name(QColor::HexRgb);
    qDebug() << choicecouleur;
    if (choicecouleur != previouschoicecouleur)
    {
        qDebug() << "envoyer";
        emit changecouleur(choicecouleur);
        previouschoicecouleur=choicecouleur;
    }
 
 
}

Buttonledpalette.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
26
27
28
29
#ifndef LEDPALETTE_H
#define LEDPALETTE_H
 
#include <QApplication>
#include <QObject>
#include<QPushButton>
#include<QColorDialog>
#include<QDebug>
class button_ledpalette : public QPushButton // On hérite de QWidget (IMPORTANT)
{
 
    Q_OBJECT
 
    public:
    button_ledpalette(QWidget *parent);
 
private:
 QString choicecouleur=nullptr;
 
QString previouschoicecouleur;
public slots:
 void paletteopen();
   void envoiebutton();
signals:
   void changecouleur(QString);
 
};
 
#endif // LEDPALETTE_H

Mainwindow.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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include "mainwindow.h"
 
 
 
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
        setWindowTitle("Centre de contrôle table tactile");
        setStyleSheet("background-color:black;");
 
         m_mainWidget= new QWidget(this);
         m_layout = new QVBoxLayout(this);
 
         m_settingWidget= new QWidget(m_mainWidget);
 
         QHBoxLayout  *m_toolbar_layout =new QHBoxLayout;
         QHBoxLayout  *m_navigate_layout =new QHBoxLayout;
         QHBoxLayout  *m_ledcolor_layout =new QHBoxLayout;
         QHBoxLayout  *m_Bouton_layout =new QHBoxLayout;
 
        QSpacerItem *spacer = new QSpacerItem(20, 0, QSizePolicy::Expanding, QSizePolicy::Preferred);
        QSpacerItem *spacerV = new QSpacerItem(0, 50, QSizePolicy::Ignored, QSizePolicy::Expanding);
 
 
        m_mainWidget->setLayout(m_layout);
        m_layout->addLayout(m_toolbar_layout);
        m_layout->addLayout(m_navigate_layout);
        m_layout->addLayout(m_ledcolor_layout);
        m_layout->addLayout(m_Bouton_layout);
 
 
        navigatefenetre *button_nav_left= new navigatefenetre(m_mainWidget,"images/fleche_gauche.png");
        navigatefenetre *button_navright= new navigatefenetre(m_mainWidget,"images/fleche_droite.png");
        button_ledpalette *btnpalette = new button_ledpalette(m_mainWidget);
        top_navbar *btnquit = new top_navbar(m_mainWidget, "images/boutonclose.png");
        top_navbar *btnsetting = new top_navbar(m_mainWidget, "images/icoreglage.png");
        QLabel *Status_Arduino = new QLabel("Status Arduino:");
        top_navbar *statusconnecte = new top_navbar(m_mainWidget, "images/statusconnect.png");
        top_navbar *statusimpossible = new top_navbar(m_mainWidget, "images/comunicationimpossible.png");
        top_navbar *statusdeconnecte = new top_navbar(m_mainWidget, "images/status deconnecter.png");
 
        m_toolbar_layout->addItem(spacer);
        m_toolbar_layout->addWidget(Status_Arduino);
        Status_Arduino->setStyleSheet("color:white;");
         m_toolbar_layout->addWidget(statusimpossible);
          m_toolbar_layout->addWidget(statusconnecte);
           m_toolbar_layout->addWidget(statusdeconnecte);
        m_toolbar_layout->addItem(spacer);
        m_toolbar_layout->addWidget(btnsetting);
        m_toolbar_layout->addWidget(btnquit);
 
        m_navigate_layout->addWidget(button_nav_left);
        m_navigate_layout->addItem(spacer);
        m_navigate_layout->addWidget(button_navright);
        m_navigate_layout->addItem(spacerV);
 
 
        m_ledcolor_layout->addItem(spacer);
        m_ledcolor_layout->addWidget(btnpalette);
        btnpalette->setStyleSheet("background-color:white;");
        m_ledcolor_layout->addItem(spacer);
        m_ledcolor_layout->addItem(spacerV);
        m_layout->addItem(spacerV);
 
        setCentralWidget(m_mainWidget);
        generalsetting *buttonsetting= new generalsetting();
        QObject::connect(btnpalette, SIGNAL(clicked()), btnpalette, SLOT(paletteopen()));
        QObject::connect(btnquit, SIGNAL(clicked()),qApp, SLOT(quit()));
            QWidget::connect(btnsetting, SIGNAL(clicked()), buttonsetting, SLOT(actualise_port()));
        QWidget::connect(btnsetting, SIGNAL(clicked()), buttonsetting, SLOT(exec()));
        QObject::connect(btnpalette, SIGNAL(changecouleur(QString)),buttonsetting, SLOT(emettrearduino(QString)));
 
 
};
 
 
MainWindow::~MainWindow()
{
}

MainWindow.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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QtWidgets>
#include <QMainWindow>
#include <QAbstractButton>
#include <QPushButton>
#include <QIcon>
#include <QSize>
#include <QPalette>
#include<QColorDialog>
#include "buttonledpalette.h"
#include"ledpalette.h"
#include"navigatefenetre.h"
#include"top_navbar.h"
#include<QGridLayout>
#include <QVBoxLayout>
#include <QSpacerItem>
#include<mousehoverimage.h>
#include"generalsetting.h"
 
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
  void setGeometry(const QRect &rect);
private:
button_ledpalette* m_buttonled;
QPushButton *button_nav;
QPushButton *boutonled;
QString couleur;
QString choicecouleur;
QWidget* m_mainWidget;
QWidget* m_settingWidget;
top_navbar *btnsetting;
QVBoxLayout* m_layout;
QGridLayout* m_toolbar_layout;
QDialog* buttonsetting;
QMainWindow *w;
 
private slots:
 
};
 
#endif // MAINWINDOW_H

et enfin 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
15
16
17
18
19
20
21
22
#include "mainwindow.h"
#include"ledpalette.h"
#include"navigatefenetre.h"
#include"buttonledpalette.h"
#include "degrisebouton.h"
 
 
#include <QApplication>
#include <QSerialPort>
#include <QSerialPortInfo>
#include <QDebug>
 
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
 
    w.show();
 
 return a.exec();
}

**Gojir4** · 09/10/2019, 18h06

Bonjour,

Vous créez un nouvel objet "QSerialPort" lorsque vous voulez fermer le port. Cela ne pourra pas fonctionner et deplus cela génére des fuites de mémoire.
Du coup la première instance de QSerialPort que vous créez n'est jamais détruite et le port jamais fermé, ce qui explique le fait que le port ne peux plus être ouvert.

Code :

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

1
2
3
4
 
accesport = new QSerialPort(currentport);  //perte de l'objet précédent QSerialPort pointé par accesport
emit accesport->aboutToClose();
accesport->close();

Vous pouvez essayer de cette façon afin d'éviter de recréer un objet qui existe déjà. Par contre il faudra bien initialiser "accesport" à nullptr dans le constructeur de la classe generalSettings (idéalement il serait bien d'initialiser tous les pointeurs).

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
 
generalsetting::generalsetting() : accesport(nullptr)
{
   //...
}
 
void generalsetting::connectionArduino()
{
//...
    if(accesport){
        emit accesport->aboutToClose();
        accesport.close();
        accesport.deleteLater();
    }
    //...
}

Il y a en plus de cela d'autres erreurs dans votre code.
- Les instances de QTimer ne sont jamais détruite et génére aussi des fuites de mémoires.
- le constructeur de la classe "generalSettings" n'appelle pas le constructeur de la class parent QDialog, l'initialisation n'est donc pas faite correctement.

Je vous invite aussi à essayer d'éviter l'utilisation des pointeurs au possible afin de limiter au maximum ce genre de déconvenue.
Par exemple, vous pouvez très bien déclarer accesport comme ceci (sans le *):

Code :

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

1
2
 
QSerialPort acessport;

Ainsi plus besoin d'utiliser "new" ou "delete" pour créer l'instance de QSerialPort car elle sera créer lors de l'initialisation de la class "generalSettings".
La même chose s'applique pour les variable membres suivantes:

Code :

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

1
2
3
4
5
6
7
 
QString port;
QString etatconnection ;
QComboBox listebaud;
QList<QSerialPortInfo> listePorts;
QStringList  listePortsDisponibles;
QTimer timer;

**poezadri** · 10/10/2019, 09h51

bonjour à toi,et surtout merci de ton retour.

J'ai réussi avancé entre les deux mais à première vu par de manières optimal donc merci de tes conseils cela va me permettre de reprendre mon code pour qu'il soit plus propre.

j'ai du mal à saisir en faite ce que tu me dit c'est qu'on peut initialiser plusieurs objets sur le même pointeur?

Code :

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

1
2
3
4
 
accesport = new QSerialPort(currentport);  //perte de l'objet précédent QSerialPort pointé par accesport
emit accesport->aboutToClose();
accesport->close();

Petites questions:

concernant les pointeurs ont ils le même fonctionnement qu'en "C"(Pas Objets) leur intérêt principale est de pouvoir modifier plusieurs valeurs depuis les fonctions ou ont ils un autre intérêt dans le cas de QT et c++?

Dans le cas ou une seule valeur doit être retourné vaut mieux utiliser return ou bien un pointeurs je n'arrive pas voir quel différence il y à entre les deux au niveaux de la mémoire

je ne comprends pas bien à quel moment l'objet sera delete avec " accesport.deleteLater()"?

et existe t'il des outils me permettant d'identifier les fuites de mémoire?

Désolé de toute ces question mais étant autodidacte beaucoup me reste sans réponse et cela n'est pas toujours évident de trouvé des réponse sur le net (surtout en français)

Merci pour la réponses je vais reprendre mon code en enlevant un max de pointeurs et en corrigeant le reste selon tes conseil

**Gojir4** · 10/10/2019, 20h06

Envoyé par poezadri

j'ai du mal à saisir en faite ce que tu me dit c'est qu'on peut initialiser plusieurs objets sur le même pointeur?

Oui, un pointeur n'est qu'une variable qui contient l'adresse d'un objet en mémoire et on peut lui assigné une autre adresse (valide ou non) à n'importe quel moment.
Par exemple:

Code :

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

1
2
3
int *i = new int(10);  //i pointe sur une zone mémoire de la taille d'un entier, contenant la valeur 10.
i = new int(20);                   //i pointe maintenant sur une nouvelle zone de mémoire, qui contient 20
//La première zone mémoire, contenant 10, est toujours existante car elle n'as pas été détruite, et il est impossible de la récupérer car le pointeur à été réassigné

Envoyé par poezadri

concernant les pointeurs ont ils le même fonctionnement qu'en "C"(Pas Objets) leur intérêt principale est de pouvoir modifier plusieurs valeurs depuis les fonctions ou ont ils un autre intérêt dans le cas de QT et c++?

Par forcément, il y a beaucoup d'autres raisons d’utiliser les pointeurs, en C comme en C++. Passer un objet de grande taille à une fonction sans avoir besoin de le copier, tableaux, listes chaînées et itération, allouer de la mémoire dynamiquement et pleins d'autre que j'oublie ou ne connaît pas...

Envoyé par poezadri

Dans le cas ou une seule valeur doit être retourné vaut mieux utiliser return ou bien un pointeurs je n'arrive pas voir quel différence il y à entre les deux au niveaux de la mémoire

Dans ce cas à mon avis il vaut mieux utiliser return.

Notez en passant que vous pouvez passer l'adresse d'une variable à une fonction qui attend un pointeur. Ce qui peut être utile dans certains cas. Exemple:

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
bool lireValeur(int *i){
    if(!valeurDisponible)
       return false;
 
    *i = lireQuelqueChose();  //Lecture quelconque, port série, fichier, stream, etc...
    return true;
}
//utilisation
int valeur = 0;
 
if(lireValeur(&valeur)){   //Passage de l'adresse de la variable valeur 
    //Lecture Ok, valeur contient le résultat
} else {
    //Lecture échouée
}

Envoyé par poezadri

je ne comprends pas bien à quel moment l'objet sera delete avec " accesport.deleteLater()"?

deleteLater() est une fonction fourni par Qt qui permet de détruire un objet de façon différée. L'objet sera détruit au début ou la fin d'un cycle de la boucle d'événement. Ce n'est pas forcément utile dans votre cas. Mais vous pouvez considérer que c'est la même chose que d'appeler

Code :

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

delete accesport;

Envoyé par poezadri

et existe t'il des outils me permettant d'identifier les fuites de mémoire?

Oui, j'ai entendu parlé de Valgrind qui est visiblement supporté par Qt Creator. Il y en a sûrement d'autre. Par contre je n'ai jamais utilisé ce genre d'outils donc je ne peux pas vous aider à ce sujet.

Je vous recommande quand même de passer quelque temps à vous familiariser avec le C++ et ses concepts de bases, fonctions, pointeurs, etc. Il y a pas mal de cours, exemple et tutos très intructifs sur ce site et d'autres, comprendre les bases vous permettra de gagner du temps par la suite. Qt fourni aussi des dizaines d'exemples disponible directement dans Qt Creator qui pourront aussi vous aider à comprendre les mécanismes de Qt.

Déconnexion / reconnexion impossible avec Arduino

Bibliothèques

Discussions similaires

Partager

Partager