Bonjour a tous,

J'ai un petit problème concernant un QString que je veux transformer en Double. Pour cela je fais appel à la fonction toDouble évidement, toute fois lorsque je fais mes tests ça me renvoie tout le temps 0.. évidement j'ai fait les tests et le booléen m'affirme bien une erreur lors de la conversion mais je ne comprends pas... 

voici mon code en raccourci :

#include "fenetre_ajout_donnees.h"
#include "fenetre_personne.h"

#include <QGridLayout>
#include <QMessageBox>
#include <QString>
#include <QDialog>
#include <QFile>
#include <QTextStream>
#include <map>
#include <QLocale>


Fenetre_ajout_donnees::Fenetre_ajout_donnees(QString nom_fichier) : m_pf("Inconnu","inconnu"),nb_personnes(0),m_fichier(nom_fichier){

    QValidator *v_solde = new 
    QDoubleValidator(0.00,99999999.00,2);
    m_solde = new QLineEdit;
    m_solde->setValidator(v_solde);
    //Je vous passe lutilisation des layouts

    QObject::connect(m_Ok, &QPushButton::clicked, this, &Fenetre_ajout_donnees::lecture_transaction);
    lecture_principale(m_fichier);
    this->setLayout(layoutPrincipal);
    this->show();
}

void Fenetre_ajout_donnees::lecture_transaction(){
    double d_montant,total;
    bool ok;
    QString s_montant,s_solde;
    
    //m_signep est un bouton radio initialisé ci dessus je vous passe sa creation
    if(m_signep->isChecked()){
        s_montant = m_solde->text();
    }
    else{
        s_montant = "-"+m_solde->text();
    }
    d_montant = QLocale().toDouble(s_solde,&ok);
    if(ok){
        QMessageBox::information(nullptr,"OK","ca marche!!");
    }
    else {
        QMessageBox::information(nullptr,"pas ok","ca marche pas...");
    }

}

Merci aux ames charitable

Salut,

Déjà, tu aurais beaucoup plus facile si tu ne déclarais qu'une variable par ligne, et si tu veillais à ne déclarer les variable qu'au plus près de leur première utilisation!

C'est quoi ces horreur de

double d_montant,total;

et de

QString s_montant,s_solde;

??? !!!!

Tu commence par travailler sur une QString, que tu appelle s_montant (pourquoi pas "montant", tout simplement ????).  Commence donc par déclarer ces variable avant de l'utiliser.  Vu que tu n'utilisera pas ok et d_solde (pourquoi pas solde, tout simplement ???) directement, attend d'en avoir besoin pour déclarer ces variables

Un code proche de

void Fenetre_ajout_donnees::lecture_transaction(){
    QString montant 
    
    if(m_signep->isChecked()){
        s_montant = m_solde->text();
    }
    else{
        s_montant = "-"+m_solde->text();
    }
    double montant;
    bool ok;
    montant = QLocale().toDouble(solde,&ok);
    if(ok){
        QMessageBox::information(nullptr,"OK","ca marche!!");
    }
    else {
        QMessageBox::information(nullptr,"pas ok","ca marche pas...");
    }

fera exactement la même chose en évitant bien des erreurs, vu que chaque variable est déclarée juste avant d'être utilisée.  Il nous permet, en outre, de nous rendre compte que les variables total et s_solde ne servaient à rien, vu qu'elle n'étaient jamais utilisées ;).  Il n'y avait donc aucune raison de déclarer ces deux variables!

Ensuite, si je n'ai rien contre le fait que l'on décide de préfixer les données membres d'une classe par m_ pour pouvoir les distinguer facilement des variables locales aux différentes fonctions, le fait de commencer à préfixer des variables locales de s_ pour indiquer que tu as affaire à une chaine de caractères ou de d_ pour indiquer que tu as faire à un double s'apparente à ce que l'on appelle la notation hongroise.

Cette notation ne t'apporte absolument rien (ou en tout cas rien de bon), dés le moment où la déclaration de tes variables a lieu "le plus près possible" de leur utilisation.  Pourquoi donc voudrais tu y avoir recours?

Et c'est d'autant plus vrai que tu n'y a pas recours de manière systématique, vu que tu avais déclaré une variable total qui était de type double (alors que tu aurais donc du l'appeler d_total, pour être cohérent) et une variable ok qui était de type bool (et que tu aurais donc du l'appeler b_ok pour être cohérent)!

Retiens toujours un point essentiel : tes conventions de nommage -- quelle qu'elles soient -- doivent toujours être identiques et cohérentes:

• au niveau d'une fonction
• au niveau d'un fichier
• au niveau de l'ensemble de ton projet

Si tu commences à mélanger des conventions de nommabe à l'un de ces niveau, si tu décide de les appliquer "parfois" et "parfois pas", ce ne sont plus des conventions de nommage et, tôt ou tard, tu finiras par ne plus t'y retrouver dans ton propre code.

Or, tu auras déjà largement suffisamment de raisons pour en arriver à ne plus te retrouver dans ton propre code. Veilles donc à ne pas en ajouter "plus que nécessaire"