Hello,

je souhaite récupérer des informations venant d'un fichier à l'aide d'une boucle.

Les données du fichier sont sous la forme:

entite username password

Pour lire mon fichier, j'utilise la fonction suivante:

int read()
{
    string log;
    cout << endl << "Numeros de log ?" << endl <<">> ";
    cin >> log;
    log += ".data";
    ifstream f_log(log.c_str());
    string entite,username, password;
    string script;
    while(f_log)
    {
        f_log >> entite;
        f_log >> username;
        f_log >> password;
        cout <<endl<<entite<<" "<<username<<" "<<password<<endl;
    }
    return 1;
}

Le problème c'est que j'ai en retour une pelote de chaine (je ne sais pas comment le dire autrement).

Voici le code complet:

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int crea();
int report();
int suppr();
int read();

int main()
{
    cout << "Lancement" << endl;
    bool loop(false);
    string buffer;
    while (!loop)
    {
        //Saisie de texte
        cout << endl << ">> ";
        cin >> buffer;

        if(buffer=="creation")
        {
            if(!crea())
            {
                cout << "Erreur" <<endl;
            }
        }
        else if (buffer=="suppression")
        {
            if(!suppr())
            {
                cout << "Erreur" <<endl;
            }
        }
        else if (buffer=="report")
        {
            if(!report())
            {
                cout << "Erreur" <<endl;
            }
        }
        else if (buffer=="lecture")
        {
            if(!read())
            {
                cout << "Erreur" <<endl;
            }
        }
        else if (buffer=="sortie")
        {
            loop = true;
        }
        else{cout << "Erreur saisie non-reconnue"<< endl;}
    }
    return 0;
}

int crea()
{
    string log;
    cout << endl << "Numeros de log ?" << endl <<">> ";
    cin >> log;
    log += ".data";
    ofstream f_log(log.c_str(), ios::app);
    bool l_crea(false);
    string entite,username, password;
    string script;
    while(!l_crea)
    {
        cout <<endl<< "Entite:"<< endl << ">> ";
        cin >> entite;
        if(entite=="stop")
        {
            l_crea = true;
        }
        else
        {
            cout <<endl<< "Nom d'utilisateur:"<< endl << ">> ";
            cin >> username;
            cout <<endl<< "Mot de passe:"<< endl << ">> ";
            cin >> password;
            script += entite;
            script += " ";
            script += username;
            script += " ";
            script += password;

            cout << endl << script<< endl;
            f_log << script <<endl;
            cout << "Ajout de Texte terminer" <<endl;
        }

    }
return 1;
}

int suppr()
{
    string log;
    cout << endl << "Numeros de log a supprimer ?" << endl <<">> ";
    cin >> log;
    log += ".data";
    remove(log.c_str());
    cout << endl <<"Log supprimer"<<endl;
    return 1;
}

int read()
{
    string log;
    cout << endl << "Numeros de log ?" << endl <<">> ";
    cin >> log;
    log += ".data";
    ifstream f_log(log.c_str());
    string entite,username, password;
    string script;
    while(f_log)
    {
        f_log >> entite;
        f_log >> username;
        f_log >> password;
        cout <<endl<<entite<<" "<<username<<" "<<password<<endl;
    }
    return 1;
}

int report()
{
    string log;
    cout << endl << "Numeros de log ?" << endl <<">> ";
    cin >> log;
    log += ".data";
    //Creation du fichier HTML
    return 1;
}

J'ai créer un fichier 0000.data à l'aide du créateur du programme (il faut entrer creation puis 0000 entrer les valeur puis stop), voici le contenu:

test_a test_a test_a
test_b test_b test_b

Et voici ce que donne la lecture:

je dois avouer que je e comprends pas d'où viens le problème, je pense que cela peut venir d'une mauvaise gestion du curseur avec le f_log>>

Merci de votre aide

using namespace std, c'est mal.

Concernant ton problème, il vient du contrôle de validité de ton flux.

while(f) // << au dernier tour, le flux est encore valide
{
   using std::cout;
   using std::endl;
   f >> entite; /* << on tombe sur eof, le flux devient invalide, 
                      rien n'est écrit dans entite */
   f >> user;   /* toujours invalide, rien n'est écrit dans user */
   f >> pass;   /* toujours invalide, rien n'est écrit dans pass */

   /*
      affichage, le flux ayant été invalidé pendant la boucle, les 
      variables entite, user et pass, n'ont pas été modifiées...
   */
   cout << entite << " " << user << " " << pass << endl;
}

Pour avoir quelque chose de beaucoup plus propre, il faut structurer plus et respecter strictement le principe de responsabilité unique(SRP). Le principe de responsabilité unique dit qu'on ne doit confier qu'une seule tâche à un objet d'un programme, sinon ça devient trop compliqué pour nos petite têtes.

Ta fonction fait 2 choses, lire le fichier et afficher son contenu. C'est trop compliqué, la preuve tu n'y arrive pas Pour que ce soit plus facile, il faudrait faire 2 fonctions, une qui lit le fichier et une qui affiche son contenu. Comment faire ça? en structurant:

Ici nous voyons que ta donnée de base est un groupe de 3 chaînes de caractères, chaque châine ayant une fonction bien définie, l'idée naturelle va être de les regrouper dans une structure, c'est à dire créer un nouveau type de donnée spécialement conçu pour contenir 3 chaînes de caractères:

struct UserInfo
{
   std::string entite_;
   std::string user_;
   std::string pwd_;
};

A partir de là, si je veux manipuler un ensemble de UserInfo, je vais utiliser un tableau dynamique:

#include<vector>

using UserList = std::vector<UserInfo>;

Grâce au SRP et à la structuration, la lecture de mon fichier sera une fonction qui place le contenu du fichier dans un UserList

UserList readUserList(std::string const & fileName);

Et l'affichage sera une autre fonction qui affiche un UserList

void print(UserList const & list);

Découpons encore un peu la lecture dans un fichier, en vertu de SRP, lire un UserList dans un fichier, c'est trop compliqué, par contre lire une ligne dans le fichier, ça on sait faire, pas de souci, il n'ous reste à faire une fonction qui va fabriquer un UserInfo à partir d'une ligne du fichier:

UserInfo construct(std::string const & fileLine);

Muni de cette fonction, ma fonction readUserList devient facile à écrire:

UserList readUserList(std::string const & fileName)
{
   std::ifstream file{fileName};
   UserList result;
   std::string line;
   while(std::getline(file,line)){
      result.push_back(construct(line));
   }
   return result;
}

int21h

je suis débutant j'en sui s que à la deuxième partie du cours M.Nebra sur le C++ XD

j'ai pas compris grand chose au premier regard, ni a deuxième !

Je comprends l'utilité de la structure, mais pas le UserList:

#include<vector>
 
using UserList = std::vector<UserInfo>;

Que signifie cette ligne, plus particulièrement le using ?

Le SRP chez moi c'est erreur 404, j'ai regardé sur internet j'ai compris que ça implique de respecter les héritages mais comment mystère!

Après j'ai du mal à comprendre comment faire :

UserInfo construct(std::string const & fileLine);

SRP: Single Resposability Principle (Principe de responsabilité unique), ça n'a strictement rien à voir avec l'héritage. C'est la formalisation d'un  vieil adage de bon sens populaire que l'on peut traduire par "Je ne sais faire qu'une seule chose, mais je la fais bien" ou par le plus ambigü "Diviser pour règner".

L'idée c'est que tu dois découper ton programme en tâches les plus simple possibles, typiquement une tâche simple = une fonction. Pour construire un programme, tu assembles tes tâches simples à la manière d'un légo, pour construire des tâches de plus en plus complexes. Après SRP ne s'applique pas seulement aux fonctions, c'est aussi un des piliers fondamentaux de la programmation orientée objet et l'idée reste la même, toujours découper pour obtenir des trucs hyper simples, hyper compact, facile à construire, facile à debugger, facile à corriger si par malchance on a réussi a se tromper (mais plus c'est simple, moins on risque de se tromper, c'est une stratégie où on gagne pratiquement à tous les coups).

Concernant le cours de C++ d'Open Classroom, je te conseille d'en changer. Il est complètement dépassé, et contient en plus un paquet d'âneries. En ligne, tu as le cours de gbdivers qui bien que pas fini, est à peu près à jour et surtout ne contient presque pas de bêtises (ou alors elles sont bien planquées ). En bouquin, tu as le C++ Primer de Stanley Lipmann qui bien que commançant un peu à dater, reste à ma connaissance, le meilleur cours sur C++ disponible. Naturellement le Primer n'existe qu'en anglais, mais ce n'est pas un problème, parce que si tu veux espérer être un jour capable de faire quoi que ce soit en programmation, la maîtrise de l'anglais est un pré-requis indispensable.

Salut

Je confirme tout ce que a dit int21h (le cours de C++ OpenClassroms est dépassé, la mauvaise pratique de using namespace std, etc... )

Que signifie cette ligne, plus particulièrement le using ?

Tu as la réponse dans le lien qu'il t'a donné concernant la mauvaise utilisation de using namespace std.

Utiliser UserList revient à utiliser std::vector<UserInfo>.

Concernant le reste, int21h t'explique que tu peux séparer le travail en plusieurs fonctions :

- Une fonction qui va lire le fichier.

- Une fonction qui va récupérer une chaine (qui est une ligne de ton fichier) pour séparer les 3 données afin les placer dans un UserInfo.

- Une fonction qui va afficher toutes tes données.

Il a divisé le problème.