MelissaNgouleu a écrit:

rouloude je peut avoir un exemple stp? car je comprends pas

Il y a la possibilité de l’appeler avec l'opérateur de porté :: avant son nom ::solde[sauv] mais c'est mieux d'avoir des noms différent et encore mieux de ne pas avoir de variable global.

Je ne suis pas remonté dans la discussion afin de retrouver les messages "intéressants" pour toi, et je t'en présente mes excuses.

Je vais donc partir du principe que le message de rouloude est non seulement tout à fait juste parce que l'on peut très facilement créer des conflits entre les noms de variables globales et les noms de données membres dans une classe, mais qu'il est aussi tout à fait censé dans ta situation.

(j'ai d'autant plus facile à partir de ce principe que l'on te dis depuis le début que les variables globales c'est mal )

Donc, peut être ne l'as tu  pas encore compris, mais, une variable globale, c'est une variable dont la déclaration se trouve "quelque part" en dehors de toute portée (faisons simple : en dehors de toute paire d'accolades).  Cela pourrait ressembler à quelque chose comme

int monEntierGlobal; // ca, c'est une variable "globale"

int main(){
    float monReelLocal; // ca, c'est une variable "locale"
}

(J'ai volontairement utilisé des noms et des types différents pour éviter tout risque de confusion )

La grosse différence qu'il y a entre monEntierGlobal et monReelLocal, tient principalement du fait que monEntierGlobal est connu partout (du moins, partout où sa déclaration est accessible) par le compilateur, alors que monReelLocal n'est connu ... qu'à l'intérieur de la fonction main.

C'est d'ailleurs la raison pour laquelle on décide de faire la distinction entre les deux en qualifiant monEntierGlobal de variable globale (qui signifie "disponible partout") et monReelLocal de variable locale (qui n'est disponible que dans une partie "limitée" du code).

Pour éviter de rentrer dans des digressions qui n'apportent pas grand chose à  la compréhension de la différence, il ne nous reste qu'une seule chose à savoir: quand tu crées une classe ou une structure (*) sous une forme proche de

struct MaStruct{ // la visibilité des données n'a aucune importance
                 // pour le sujet qui nous occupe 
    int i;
    float f;
};

les données membres (les variables qui composent) de ta classe ou de ta structure sont des variables locales, vu qu'elles sont déclarées entre une paire d'accolade { et }.

Tu remarqueras que, jusqu'à présent, j'ai utilisé des noms différents pour chacune des variables que j'ai pu déclarer. Il n'y a donc absolument aucune raison pour que le compilateur confonde la donnée i qui est une donnée locale dans la structure MaStruct avec la donnée monEntierGlobal qui est une donnée globale.

Les choses se compliquent lorsque le compilateur croise, à l'intérieur d'une fonction, des variables (accessibles au niveau de cette fonctions) qui ... portent le même nom; par exemple, avec un code proche de

// voici une variable ** globale **

int i;
struct MaStruct{
    // voici une variable ** locale **
    int i;
    // et voici une fonction "à problème
    void foo(){
        i *= 5; // de quel variable i est-il question?
    }
};

Dans la fonction foo() (qui appartient à  MaStruct), le compilateur connait à la fois la variable globale ET la variable locale (au niveau de MaStruct) qui sont toutes les deux  nommées i.

Or, il se rend bien compte qu'il s'agit de deux variables totalement différentes. Et il ne sait donc pas  ce qu'il doit faire. doit il multiplier la variable globale nommée i par cinq ? ou doit il plutôt multiplier la variable locale nommée i par cinq?

Du point de vue du  compilateur, les deux choix sont tout aussi valables l'un que l'autre.  Et pourtant, il a bien "conscience" que  le résultat sera totalement différent.  Il se trouve donc face à une situation de conflit qu'il est -- dans l'état actuel des choses -- totalement incapable de résoudre.

Il se retranche donc derrière sa dernière défense pour éviter de "mal faire": il émet un message d'erreur, et il abandonne

NOTA: Nous pourrions éventuellement partir du principe que c'est la variable locale qui doit être multipliée par cinq et nous arranger pour le faire comprendre au compilateur.

Car les fonctions qui font partie d'une classe ou  d'une structure disposent systématiquement d'un pointeur sur la donnée qui est en cours de traitement appelé this.

Nous pourrions donc "contourner le problème" en indiquant explicitement au compilateur que c'est bien la variable locale à la structure que nous voulons multiplier par cinq avec un code proche de

// voici une variable ** globale **

int i;
struct MaStruct{
    // voici une variable ** locale **
    int i;
    void foo(){
        this->i *= 5; // aucun problème: le compilateur sait qu'il doit multiplier
                      // la variable i qui appartient à la donnée (de type MyStruct) en
                      // cours de "traitement"
    }
};

Et, à l'inverse, nous pourrions également dire explicitement au compilateur qu'il doit utiliser la variable globale avec un code proche de

// voici une variable ** globale **

int i;
struct MaStruct{
    // voici une variable ** locale **
    int i;
    void foo(){
        ::i*=5;
    }
};

Cependant, il vaut largement mieux voir dans toute cette histoire, dans toutes les tracasseries par lesquelles nous sommes obligés de "lever l'ambiguité" une bonne raison de plus (s'il nous en fallait encore) pour renoncer aux variables globales

Si Dieu avait voulu que nous renonçassions aux variables globales, il ne nous aurait pas envoyé  std::cin et std::cout dans son infinie miséricorde.

Le problème ici c'est qu'il y en a un peu beaucoup. Comme elles sont liées - elles servent à représenter l'état des comptes, un truc comme ça - ça serait mieux de les emballer dans une même entité, que ce soit une structure, un objet, un espace de noms.

Si le programme ne manipule d'une seule entité de ce genre, elle peut être globale, c'est pas un problème.

Mais bon, il faut y aller doucement. Il est contre productif de bassiner des débutant(e)s avec des histoires de "bonnes pratiques professionnelles" et d'architectures recommandées par des célébrités de l'informatique etc. quand ils en sont encore, par exemple, à confondre égalité et affectation, et qu'il faut leur dire de lire les messages d'erreurs quand il y en a. Chaque chose en son temps.

Imaginez, vous apprenez la guitare, vous avez du mal à vous rappeler le nom des cordes, et le prof vient vous raconter que vous devriez substituer l'accord par  un mineur 7 bemol 5 add 13, parce que c'est ce que les professionnels font.

---
PS: la question de départ, c'était bien sur l'historique ? La réponse, c'est qu'il n'y a pas de magie, si on veut pouvoir le ressortir, il faut l'avoir gardé quelque part.
Ca peut être un tableau des opérations effectuées, un fichier journal, etc. Il faut voir l'avancement du cours suivi, ce que le prof veut que l'élève mette en oeuvre dans son projet.

-
Edité par michelbillaud 19 avril 2022 à 18:12:19

michelbillaud a écrit:

Si Dieu avait voulu que nous renonçassions aux variables globales, il ne nous aurait pas envoyé  std::cin et std::cout dans son infinie miséricorde.

Je suis tout à fait d'accord avec toi... A partir du moment où la personne qui décide d'utiliser les variables globales ne le fait que "en dernier recours, parce que cela résoudra plus de problèmes que ceux que cela ne pourrait poser".

Seulement, on ne peut pas demander à un débutant d'avoir conscience de "tous les problèmes que peuvent poser les variables locales", et sa décision présente donc l'énorme risque d'être à tout le moins "biaisée", pour ne pas dire complètement aberrante dans la très grosse majorité des cas.

Je préfères donc avoir une approche (peut-être) un peu plus pragmatique du  problème et dire que "les variables locales, c'est mal" -- car c'est le cas dans la plupart des situations -- afin d'apprendre à celui à qui je m'adresse à s'en passer le plus possible, quitte à "enfoncer le clou" à chaque fois qu'il utilise une variable globale et qu'elle lui pose problème en lui disant "tu vois, ici, c'est (encore!!!) un cas à problème", plutôt que de lui dire "vas-y, parce que ce sera utile dans certains (très rares) cas" et de devoir dresser derrière toute la liste de tous les cas dans lesquels sa variable globale va poser problème.  Au risque forcément d'en oublier.

Par la suite, il sera beaucoup plus facile de lui faire comprendre que "ben, même si on t'a suriné que les variable globales étaient mal, nous sommes face à un cas particulier dans lequel elles résoudront plus de problèmes que ceux  qu'elles ne posent" et ce, d'autant plus qu'il aura -- a priori -- pris un peu de bouteille

Il y a déjà suffisamment de choses à remettre d'aplomb dans le code présenté sans charger davantage la barque.

Parce que sinon, il y a les trucs de base : une application bancaire, ça ne manipule pas des sommes sous forme de int ni des floats :-)

Si on parle de pragmatisme, il existe un truc qui s'appelle la surcharge cognitive. Si tu racontes trois trucs à la fois à un débutant, il n'en retient absolument aucun.  Donc soyons pragmatiques, n'assommons pas - même avec les meilleures intentions du monde - les débutants avec des tas de considérations supplémentaires.

-
Edité par michelbillaud 19 avril 2022 à 19:25:13

michelbillaud a écrit:

Il y a déjà suffisamment de choses à remettre d'aplomb dans le code présenté sans charger davantage la barque.

C'est bien pour cela que  nous nous sommes arrêtés dans un premier temps à "les variables globales, c'est mal".

Maintenant, comme il y avait une demande d'explications explicite, il était aussi "logique" de les fournir d'une manière "aussi  compréhensible que possible"

koala01 a écrit:

michelbillaud a écrit:

Il y a déjà suffisamment de choses à remettre d'aplomb dans le code présenté sans charger davantage la barque.

C'est bien pour cela que  nous nous sommes arrêtés dans un premier temps à "les variables globales, c'est mal".

Maintenant, comme il y avait une demande d'explications explicite, il était aussi "logique" de les fournir d'une manière "aussi  compréhensible que possible"

-
Edité par michelbillaud 19 avril 2022 à 20:11:10

Aucun de ces points n'était réellement une digression: il s'agissait plutôt de donner une explication (qui, contrairement à mes habitudes, restait relativement simple et concentrée sur le problème) des point qui étaient mis en évidence et qui correspondaient à mon sens  au noeud du problème

Car je suis malgré tout convaincu que le proverbe

Donne un poisson à quelqu'un, il mangera un jour. Apprends lui à pêcher, et il mangera toute sa vie

est tout à fait juste, et qu'il ne sert donc à rien de dire "ceci ou cela pose un problème" si ce n'est pas au moins pour expliquer comment le résoudre ou -- mieux encore -- comment l'éviter à l'avenir

-
Edité par koala01 19 avril 2022 à 21:39:44

michelbillaud a écrit:

Qui nous font d'ailleurs perdre de vue la question d'origine : comment afficher l'historique des transactions.

-
Edité par michelbillaud il y a environ 3 heures

Résolu ?

Avec les pieds !

Le programme ne permet qu'une connexion par un utilisateur unique.

Et l'historique ne fait pas mention de cet utilisateur.

Ça ne va pas du tout marcher avec un main plus sérieux, avec connexion successive de plusieurs utilisateurs. Erreur de conception du modèle de données.

-
Edité par michelbillaud 20 avril 2022 à 8:59:02

bonsoir

j'espère que vous allez tous bien

je crois que cette fois si j'ai comprise la POO, j'ai recommencé à zéro mon programme

mais j'ai 2 soucis:

1- comment corrigé cette erreur : Compte.cpp|77|error: no match for call to '(std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >) ()'|

à 1- je n'arrive pas à gérer ma variable privée historique de type vector au niveau de mes fonctions (débiter, créditer, voir_historique)

2- j'ai implémenté la fonction login dans User mais je ne connais pas comment je peut l'appeler depuis le main.cpp. j'ai plutôt implémenter la fonction login directement dans le main.cpp et non dans le user.cpp

ci-dessous mes différents fichiers

>user.hpp

#ifndef USER_H_INCLUDED
#define USER_H_INCLUDED
#include <iostream>
#include <string>
#include "Compte.h"


class User{

    private:

            std::string m_nom;
            std::string mot_de_passe;
            bool isConnected;
            Compte m_compte;

    public:

             User();
             User(std::string n, std::string p);
  /* n - nom du client
  p - mot de passe du client
  */

            std::string getNom();
            std::string getMotDePasse();
            bool getIsConnected();
            void setNom(std::string nom);
            void setMotDePasse(std::string mot_de_passe);
            void setIsConnected(bool isConnected);
            void affiche() ;
            bool login(std::string nom, std::string mot_de_passe, int id) ;

    };

#endif // USER_H_INCLUDED

>user.cpp

#include <iostream>
#include <string.h>
#include <vector>
#include <sstream>
#include "User.h"
#include "Compte.h"

using namespace std;


    User::User(): m_nom(), mot_de_passe(), m_compte()
    {

    }

    User::User(string n, string p)
    {
         m_nom = n;
         mot_de_passe = p;
         isConnected = false;
         m_compte = 100;
    }

    string User::getNom()
    {
        return m_nom;
    }

    string User::getMotDePasse()
    {
        return mot_de_passe;
    }

    bool User::getIsConnected()
    {
        return isConnected;
    }

    void User::setNom(std::string nom)
    {
       nom = nom;
    }

    void User::setMotDePasse(std::string mot_de_passe)
    {
        mot_de_passe = mot_de_passe;
    }

    void User::setIsConnected(bool isConnected)
    {
        isConnected = isConnected;
    }


   /*bool User::login(User users[6], string name, string pass, int id)
   {
        int current_user_index;

        for(int i=0; i<6; i++){
                    if(users[i].getMotDePasse() == pass && users[i].getNum() == id)
                    {
                        if(users[i].getNom() == name){

                        current_user_index = i;
                        users[current_user_index].setIsConnected(true);
                        cout<<"******connexion reussie******"<<endl;
                        cout<<"welcome"<<" "<<users[current_user_index].getNom()<<endl;
                        }

                     }

            }
             return users[current_user_index].getIsConnected();
        }*/

>compte.h

#ifndef COMPTE_H_INCLUDED
#define COMPTE_H_INCLUDED
#include <iostream>
#include <vector>
#include <string.h>


class Compte
{
  public:
    Compte();
    Compte(int montant);
    int getSolde() const;
    std::vector <std::string> getHistorique();
    void setHistorique(std::vector <std::string> historique);
    void crediter(Compte soldes[],int current_user_index ,int montant);
    void debiter(Compte soldes[],int current_user_index ,int montant);
    void afficher();
    void voir_historique();


  private:
    int m_solde;
    std::vector <std::string> historique;
};

#endif // COMPTE_H_INCLUDED

>compte.cpp

#include <iostream>
#include <vector>
#include <sstream>
#include "Compte.h"



using namespace std;

namespace patch
{
    template < typename T > std::string to_string( const T& montant )
    {
        std::ostringstream stm ;
        stm << montant ;
        return stm.str() ;
    }
}
    Compte::Compte():  m_solde(0)
    {

    }

    Compte::Compte(int montant) : m_solde(montant)
    {

    }

    int Compte::getSolde() const
    {
      return m_solde;
    }

     std::vector <std::string> Compte::getHistorique()
    {
        return historique;
    }

    void Compte::setHistorique(std::vector <std::string> historique)
    {
        historique = historique;
    }

   void Compte::crediter(Compte soldes[],int current_user_index ,int montant)
    {
        cout<<"entrer le montant a crediter"<<endl;
        cin>>montant;

        while (montant != 0)
        {
            if(montant > 0)
            {
                m_solde = m_solde + montant;
                historique.push_back("vous avez crediter votre compte de:" +patch::to_string(montant)+ " et votre nouveau solde est de :" +patch::to_string(soldes[current_user_index].getSolde()));

            }

        }
    }

     void Compte::debiter(Compte soldes[],int current_user_index ,int montant)
    {
         cout<<"entrer le montant a debiter"<<endl;
         cin>>montant;

         while(montant != 0)
         {
             if(montant > 0)
             {
                    if((m_solde - montant) < 100)
                        {
                            cout<<"solde insuffisant, veillez choisir un montant inferieur"<<endl;
                        }

                        else{
                                m_solde = m_solde - montant;
                                historique().push_back("vous avez debiter votre compte de:"+ patch::to_string(montant)+ " et votre nouveau solde est de :" +patch::to_string(soldes[current_user_index].getSolde()));
                        }
              }
        }
    }


    void Compte::voir_historique()
    {
        cout<<"vous avez effectuer les operations suivantes:"<<endl;
        for(int i=0; (unsigned)i<historique.size(); i++){
            cout<<(i+1)<<"."<<historique.at(i)<<endl;
        }
        cout<<"---------votre satisfaction c'est notre priorite, aurevoir!!!------------"<<endl;

    }

    void Compte::afficher()
    {
        cout<<"votre solde est de:"<<getSolde()<<" euros "<<endl;
    }

>main.cpp

#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <cstdlib>
#include "User.h"
#include "Compte.h"

using namespace std;
int current_user_index;
string name;
string pass;
//int id;
int n;
int montant;

User u1 = User::User("jade","jade");
User u2 = User::User("mathis","mathis");
User u3 = User::User("joyce","joyce");
User u4 = User::User("aurelie","aurelie");
User u5 = User::User("martial","martial");
User u6 = User::User("melissa","melissa");
User users[6] = {u1, u2, u3, u4, u5, u6};

Compte c1 = Compte::Compte(100);
Compte c2 = Compte::Compte(100);
Compte c3 = Compte::Compte(100);
Compte c4 = Compte::Compte(100);
Compte c5 = Compte::Compte(100);
Compte c6 = Compte::Compte(100);
Compte soldes[6] = {c1, c2, c3, c4, c5, c6};




int main()
{
    cout<<"---------ma banque-----------"<<endl;
    cout<<"*********connexion***********"<<endl;

    do{

        cout<<"entrez votre nom"<<endl;
        cin>>name;
        cout<<"saisir le mot de passe"<<endl;
        cin>>pass;
        current_user_index = -1;
            for(int i=0; i<6; i++){

                    if(users[i].getNom() == name)
                    {
                        if(users[i].getMotDePasse() == pass ){

                            current_user_index = i;
                            users[current_user_index].setIsConnected(true);
                            cout<<"******connexion reussie******"<<endl;
                            cout<<"welcome"<<" "<<users[current_user_index].getNom()<<endl;
                        }

                     }
            }

    }while(current_user_index==-1);



    do{

         cout<<"*************************tableau de bord************************"<<endl;
         cout<<"------------------bienvenue dans notre banque-------------------"<<endl;
         cout<<"------------------choisir une operation-------------------------"<<endl;
         cout<<"1:crediter votre compte"<<endl;
         cout<<"2:debiter votre compte"<<endl;
         cout<<"3:consulter l'historique des transactions"<<endl;
         cout<<"4:consulter l'etat du compte"<<endl;
         cout<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl;
         cin>>n;

    switch (n) {

    case 1:
        system("CLS");
         soldes[current_user_index].crediter( soldes, current_user_index , montant);
        break;
    case 2:
        system("CLS");
        soldes[current_user_index].debiter(soldes, current_user_index , montant);
        break;
    case 3:
        system("CLS");
        soldes[current_user_index].voir_historique();
        break;
    case 4:
        system("CLS");
       soldes[current_user_index].afficher();
        break;
    default:
        system("CLS");
        cout<<"---------bien vouloir choisir une operation existante------------"<<endl;
    }

    }while( n!=3);

}

merci 

MelissaNgouleu a écrit:

1- comment corrigé cette erreur : Compte.cpp|77|error: no match for call to '(std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >) ()'|

C'est là que la notation hongroise (m_ pour les champs) est utile.

Parce que la ligne 41 de compte.cpp, comment dire, ..., ça pue.

merci, j'ai corrigé les erreurs

ca fonctionne

que me proposez vous pour optimiser ce code? 

-
Edité par MelissaNgouleu 21 avril 2022 à 19:55:24

Pour la création de tes user et tes compte,  on est plus dans les définition de fonction membre il ne faut plus mettre le nom de la classe :

User u1 = User::User("jade","jade");

mais :

User u1 = User("jade","jade");

et encore mieux :

User u1 {"jade", "jade"};

j'ai rectifié

>compte.cpp (la ligne 41 a été refaite)

#include <iostream>
#include <vector>
#include <sstream>
#include "Compte.h"



using namespace std;

namespace patch
{
    template < typename T > std::string to_string( const T& montant )
    {
        std::ostringstream stm ;
        stm << montant ;
        return stm.str() ;
    }
}
    Compte::Compte():  m_solde(0)
    {

    }

    Compte::Compte(int montant) : m_solde(montant)
    {

    }

    int Compte::getSolde() const
    {
      return m_solde;
    }

     std::vector <std::string> Compte::getHistorique()
    {
        return m_historique;
    }

    void Compte::setHistorique(std::vector <std::string> historique)
    {
        m_historique = historique;
    }

   void Compte::crediter(Compte soldes[],int current_user_index ,int montant)
    {
        cout<<"entrer le montant a crediter"<<endl;
        cin>>montant;

        while (montant != 0)
        {
            if(montant > 0)
            {
                m_solde = m_solde + montant;
                m_historique.push_back("vous avez crediter votre compte de:" +patch::to_string(montant)+ " et votre nouveau solde est de :" +patch::to_string(soldes[current_user_index].getSolde()));

            }

        }
    }

     void Compte::debiter(Compte soldes[],int current_user_index ,int montant)
    {
         cout<<"entrer le montant a debiter"<<endl;
         cin>>montant;

         while(montant != 0)
         {
             if(montant > 0)
             {
                    if((m_solde - montant) < 100)
                        {
                            cout<<"solde insuffisant, veillez choisir un montant inferieur"<<endl;
                        }

                        else{
                                m_solde = m_solde - montant;
                                m_historique.push_back("vous avez debiter votre compte de:"+ patch::to_string(montant)+ " et votre nouveau solde est de :" +patch::to_string(soldes[current_user_index].getSolde()));
                        }
              }
        }
    }


    void Compte::voir_historique()
    {
        cout<<"vous avez effectuer les operations suivantes:"<<endl;
        for(int i=0; (unsigned)i<m_historique.size(); i++){
            cout<<(i+1)<<"."<<m_historique.at(i)<<endl;
        }
        cout<<"---------votre satisfaction c'est notre priorite, aurevoir!!!------------"<<endl;

    }

    void Compte::afficher()
    {
        cout<<"votre solde est de:"<<getSolde()<<" euros "<<endl;
    }

>main.cpp(concernant la création des users et compte)

#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <cstdlib>
#include "User.h"
#include "Compte.h"

using namespace std;
int current_user_index;
string name;
string pass;
//int id;
int n;
int montant;

User u1 = User("jade","jade");
User u2 = User("mathis","mathis");
User u3 = User("joyce","joyce");
User u4 = User("aurelie","aurelie");
User u5 = User("martial","martial");
User u6 = User("melissa","melissa");
User users[6] = {u1, u2, u3, u4, u5, u6};

Compte c1 = Compte(100);
Compte c2 = Compte(100);
Compte c3 = Compte(100);
Compte c4 = Compte(100);
Compte c5 = Compte(100);
Compte c6 = Compte(100);
Compte soldes[6] = {c1, c2, c3, c4, c5, c6};




int main()
{
    cout<<"---------ma banque-----------"<<endl;
    cout<<"*********connexion***********"<<endl;

    do{

        cout<<"entrez votre nom"<<endl;
        cin>>name;
        cout<<"saisir le mot de passe"<<endl;
        cin>>pass;
        current_user_index = -1;
            for(int i=0; i<6; i++){

                    if(users[i].getNom() == name)
                    {
                        if(users[i].getMotDePasse() == pass ){

                            current_user_index = i;
                            users[current_user_index].setIsConnected(true);
                            cout<<"******connexion reussie******"<<endl;
                            cout<<"welcome"<<" "<<users[current_user_index].getNom()<<endl;
                        }

                     }
            }

    }while(current_user_index==-1);



    do{

         cout<<"*************************tableau de bord************************"<<endl;
         cout<<"------------------bienvenue dans notre banque-------------------"<<endl;
         cout<<"------------------choisir une operation-------------------------"<<endl;
         cout<<"1:crediter votre compte"<<endl;
         cout<<"2:debiter votre compte"<<endl;
         cout<<"3:consulter l'historique des transactions"<<endl;
         cout<<"4:consulter l'etat du compte"<<endl;
         cout<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl;
         cin>>n;

    switch (n) {

    case 1:
        system("CLS");
         soldes[current_user_index].crediter( soldes, current_user_index , montant);
        break;
    case 2:
        system("CLS");
        soldes[current_user_index].debiter(soldes, current_user_index , montant);
        break;
    case 3:
        system("CLS");
        soldes[current_user_index].voir_historique();
        break;
    case 4:
        system("CLS");
       soldes[current_user_index].afficher();
        break;
    default:
        system("CLS");
        cout<<"---------bien vouloir choisir une operation existante------------"<<endl;
    }

    }while( n!=3);

}

Tu ne t'es toujours pas séparé de tes variables globales.

Sépare toi aussi des tableaux du C et opte pour std::array au pire.

Bonsoir

bonsoir 

après avoir lu différents cours sur le std::array , j'ai modifié mon code afin d'implémenté la théorie. mais hélas des erreurs depuis hier se poursuivent.

est - ce que je fais comme il se doit, ou bien j'ai comprise de travers?

merci pour toutes vos différentes participations. j'apprends beaucoup de notion auprès de vous même comme il y'a des personnes sévères mais ce n'est pas grave.

ci-dessous les différents fichiers:

>CUser.h

#ifndef USER_H_INCLUDED
#define USER_H_INCLUDED
#include <iostream>
#include <array>
#include <tuple>
#include <string>

#include "CBancaire.h"


class CUser{

    private:

            std::string m_nom;
            std::string mot_de_passe;
            bool isConnected;
            CBancaire m_compte;
            std::array <std::string, 6> users ;

    public:

            CUser();
             CUser(std::string n, std::string p);
  /* n - nom du client
  p - mot de passe du client
  */

            std::string getNom();
            std::string getMotDePasse();
            bool getIsConnected();
            void setNom(std::string nom);
            void setMotDePasse(std::string mot_de_passe);
            void setIsConnected(bool isConnected);
            void affiche() ;
            bool login(std::string nom, std::string mot_de_passe, int id) ;

    };

#endif // USER_H_INCLUDED

>CUser.cpp

#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <array>
#include <tuple>
#include "CUser.h"
#include "CBancaire.h"

using namespace std;


    CUser::CUser(): m_nom(), mot_de_passe(), m_compte()
    {

    }

    CUser::CUser(string n, string p)
    {
         m_nom = n;
         mot_de_passe = p;
         isConnected = false;
         m_compte = 100;
    }

    string CUser::getNom()
    {
        return m_nom;
    }

    string CUser::getMotDePasse()
    {
        return mot_de_passe;
    }

    bool CUser::getIsConnected()
    {
        return isConnected;
    }

    void CUser::setNom(std::string nom)
    {
       nom = nom;
    }

    void CUser::setMotDePasse(std::string mot_de_passe)
    {
        mot_de_passe = mot_de_passe;
    }

    void CUser::setIsConnected(bool isConnected)
    {
        isConnected = isConnected;
    }


   /*bool User::login(const array < string ,  6 >  & users , string name, string pass, int id)
   {
        int current_user_index;

        for(int i=0; i<6; i++){
                    if(users[i].getMotDePasse() == pass && users[i].getNum() == id)
                    {
                        if(users[i].getNom() == name){

                        current_user_index = i;
                        users[current_user_index].setIsConnected(true);
                        cout<<"******connexion reussie******"<<endl;
                        cout<<"welcome"<<" "<<users[current_user_index].getNom()<<endl;
                        }

                     }

            }
             return users[current_user_index].getIsConnected();
        }*/

>CBancaire.h

#ifndef COMPTE_H_INCLUDED
#define COMPTE_H_INCLUDED
#include <iostream>
#include <vector>
#include <array>
#include <tuple>
#include <string>


class CBancaire
{
  public:
    CBancaire();
    CBancaire(int montant);
    int getSolde() const;
    std::vector <std::string> getHistorique();
    void setHistorique(std::vector <std::string> historique);
    void crediter(const std::array < std::string ,  6 >  & soldes, int current_user_index ,int montant);
    void debiter(const std::array < std:string ,  6 >  & soldes, int current_user_index ,int montant);
    void afficher();
    void voir_historique();


  private:
    int m_solde;
    std::vector <std::string> m_historique;
    std::array <std::string, 6> soldes ;

};

#endif // COMPTE_H_INCLUDED

>CBancaire.cpp

#include <iostream>
#include <vector>
#include <sstream>
#include <string>
#include <array>
#include <tuple>
#include "CBancaire.h"



using namespace std;

namespace patch
{
    template < typename T > std::string to_string( const T& montant )
    {
        std::ostringstream stm ;
        stm << montant ;
        return stm.str() ;
    }
}
    CBancaire::CBancaire():  m_solde(0)
    {

    }

    CBancaire::CBancaire(int montant) : m_solde(montant)
    {

    }

    int CBancaire::getSolde() const
    {
      return m_solde;
    }

     std::vector <std::string> CBancaire::getHistorique()
    {
        return m_historique;
    }

    void CBancaire::setHistorique(std::vector <std::string> historique)
    {
        m_historique = historique;
    }

   void CBancaire::crediter(const array < string ,  6 >  & soldes,int current_user_index ,int montant)
    {
        cout<<"entrer le montant a crediter"<<endl;
        cin>>montant;

        if (montant == 0)
        {
            cout<<"impossible d'effectuer cette operation"<<endl;
        }
        else{
                 if(montant > 0)
                 {
                    m_solde = m_solde + montant;
                    m_historique.push_back("vous avez crediter votre compte de:" +patch::to_string(montant)+ " et votre nouveau solde est de :" +patch::to_string(soldes[current_user_index].getSolde()));

                 }

        }


    }

     void CBancaire::debiter(const array < string ,  6 >  & soldes,int current_user_index ,int montant)
    {
         cout<<"entrer le montant a debiter"<<endl;
         cin>>montant;

         if(montant == 0)
         {
             cout<<"impossible d'effectuer cette operation"<<endl;
         }
         else{
                if(montant > 0)
                     {
                    if((m_solde - montant) < 100)
                        {
                            cout<<"solde insuffisant, veillez choisir un autre montant"<<endl;
                        }

                        else{
                                m_solde = m_solde - montant;
                                m_historique.push_back("vous avez debiter votre compte de:"+ patch::to_string(montant)+ " et votre nouveau solde est de :" +patch::to_string(soldes[current_user_index].getSolde()));
                        }
                     }
              }
    }


    void CBancaire::voir_historique()
    {
        cout<<"vous avez effectuer les operations suivantes:"<<endl;
        for(int i=0; (unsigned)i<m_historique.size(); i++){
            cout<<(i+1)<<"."<<m_historique.at(i)<<endl;
        }
        cout<<"---------votre satisfaction c'est notre priorite, aurevoir!!!------------"<<endl;

    }

    void CBancaire::afficher()
    {
        cout<<"votre solde est de:"<<getSolde()<<" euros "<<endl;
    }

>main.cpp

#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <cstdlib>
#include <array>
#include <tuple>
#include "CUser.h"
#include "CBancaire.h"

using namespace std;


int main()
{
    int current_user_index;
    string name;
    string pass;
    int n;
    int montant;

    array < string ,  6 >  users  =  { "jade" , "mathis" , "joyce" , "aurelie" , "martial", "melissa" } ;

    array < string ,  6 >  soldes  =  { "jade" , "mathis" , "joyce" , "aurelie" , "martial", "melissa" } ;

    cout<<"---------ma banque-----------"<<endl;
    cout<<"*********connexion***********"<<endl;

    do{

        cout<<"entrez votre nom"<<endl;
        cin>>name;
        cout<<"saisir le mot de passe"<<endl;
        cin>>pass;
        current_user_index = -1;
            for(int i=0; i<6; i++){

                    if(users[i].getNom() == name)
                    {
                        if(users[i].getMotDePasse() == pass ){

                            current_user_index = i;
                            users[current_user_index].setIsConnected(true);
                            cout<<"******connexion reussie******"<<endl;
                            cout<<"welcome"<<" "<<users[current_user_index].getNom()<<endl;
                        }

                     }
            }

    }while(current_user_index==-1);



    do{

         cout<<"*************************tableau de bord************************"<<endl;
         cout<<"------------------bienvenue dans notre banque-------------------"<<endl;
         cout<<"------------------choisir une operation-------------------------"<<endl;
         cout<<"1:crediter votre compte"<<endl;
         cout<<"2:debiter votre compte"<<endl;
         cout<<"3:consulter l'historique des transactions"<<endl;
         cout<<"4:consulter l'etat du compte"<<endl;
         cout<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl;
         cin>>n;

    switch (n) {

    case 1:
        system("CLS");
         soldes[current_user_index].crediter( soldes, current_user_index , montant);
        break;
    case 2:
        system("CLS");
        soldes[current_user_index].debiter(soldes, current_user_index , montant);
        break;
    case 3:
        system("CLS");
        soldes[current_user_index].voir_historique();
        break;
    case 4:
        system("CLS");
       soldes[current_user_index].afficher();
        break;
    default:
        system("CLS");
        cout<<"---------bien vouloir choisir une operation existante------------"<<endl;
    }

    }while( n!=3);

}

merci

-
Edité par MelissaNgouleu 22 avril 2022 à 16:19:09

Il y a que des étourderies que tu devrais être capable de corriger toi même si tu relisais un peu ton code en plus le compilateur te donne les ligne si tu ne comprend pas ce qu'il te dit !

L'opérateur de résolution de portée c'est :: et non pas :

Dans ton main, tes utilisateur sont des std::string et tu essais de les utiliser comme des CUser (de ta classe CUser) Forcement ça colle pas !

etc...

Recommandation standard puisqu'on est dans le "refactoring" (*) : quand on fait des changements, en faire _un minimum_ à chaque fois, pour avoir constamment un code sans erreur de compillation.

Par exemple si on décide de suivre le conseil standard : "mettre le préfixe m_ aux données membres pour ne pas les confondre avec les autres variables :

• changer *un* nom dans la définition (m_mot_de_passe, qui a été oublié).
• remplacer ses occurrences dans le code
• compiler pour vérifier qu'on n'a rien oublié
• exécuter pour s'assurer qu'on n'a pas fait une bêtise en substituant là où il fallait pas.

(*) activité consistant à transformer un code pour le rendre plus propre, mieux structuré, plus maintenable etc. sans modifier ses fonctionnalités.  En principe on part d'un code qui marche (sinon on serait en recherche/correction d'erreur, autre boulot), en tout cas on ne cherche pas à ajouter des choses. Plutot à simplifier et nettoyer.

----

Pour compléter, si on décide de pousser un peu dans le sens d'une approche objet, on peut s'en servir pour délimiter clairement

• la partie du programme (instructions et données) qui contient les informations relatives aux comptes
• la partie qui est chargée de dialoguer avec l'utilisateur.

int main()
{
    Bank bank;
    bank.add_account("alice", "aaa", 123);
    bank.add_account("bob", "bbb", 456);

    Dialog dialog{bank};
    while (true) {
        dialog.run_session();
        std::cout << "Autre utilisateur (o/n) ?";
        std::string answer;
        std::cin >> answer;
        if (answer == "n") break;
    }
    return EXIT_SUCCESS;
}

#include <iostream>
#include <map>

class Account
{
    std::string m_name;
    std::string m_password;
    int m_amount;

public:
    Account(const std::string &name,
            const std::string &password,
            int amount)
        : m_name{name},
          m_password{password},
          m_amount{amount}
    {}

    std::string & password()
    {
        return m_password;
    }

    int & amount()
    {
        return m_amount;
    }

};

class Bank
{
    std::map<std::string, Account> m_accounts;
public:
    void add_account(const std::string &name, const std::string &password, int amount = 0)
    {
        Account a{name, password, amount};
        m_accounts.emplace(name, a);
    }

    bool authenticate(const std::string &name, const std::string &password)
    {
        auto a = m_accounts.find(name);
        if (a == m_accounts.end()) {
            std::cout << name << "absent" << std::endl;
            return false;
        }
        return a != m_accounts.end()
               && (a->second.password() == password);
    };

    int & amount(const std::string & name)
    {
        return m_accounts.at(name).amount();
    }

};

// interface utilisateur.
class Dialog
{
private:
    Bank & m_bank;
public:
    Dialog(Bank & bank)
        : m_bank{bank}
    {}

    void withdraw_cash(const std::string &name)
    {
        std::cout << "Combien ? ";
        int amount;
        std::cin >> amount;
        m_bank.amount(name) -= amount;
    }

    void session(const std::string &name)
    {
        std::cout << "Bonjour " << name << std::endl;
        while (true) {
            std::cout << "Votre solde est de " << m_bank.amount(name) << std::endl;
            std::cout << "Opération" << std::endl
                      << "- r : retrait" << std::endl
                      << "- q : quitter" << std::endl
                      << "> ";
            std::string operation;
            std::cin >> operation;
            if (operation == "r") {
                withdraw_cash(name);
            } else if (operation == "q") {
                break;
            } else {
                std::cout << "No comprendo" << std::endl;
            }
        }
        std::cout << "Au revoir, " << name << " !" << std::endl;
        return;
    }
    void run_session()
    {
        std::string name, password;
        std::cout << "Vous êtes    ? ";
        std::cin >> name;
        std::cout << "mot de passe ?";
        std::cin >> password;

        if (! m_bank.authenticate(name, password)) {
            std::cout << "Client inconnu ou mot de passe incorrect. Au revoir.";
            return;
        }

        session(name);
    }
};

int main()
{
    Bank bank;
    bank.add_account("alice", "aaa", 123);
    bank.add_account("bob", "bbb", 456);

    Dialog dialog{bank};
    while (true) {
        dialog.run_session();
        std::cout << "Autre utilisateur (o/n) ?";
        std::string answer;
        std::cin >> answer;
        if (answer == "n") break;
    }
    return EXIT_SUCCESS;
}

$ make
g++ -std=c++20 -Wall -Wextra -pedantic -Werror -Wno-unused -g    prog.cc   -o prog
$ ./prog 
Vous êtes    ? alice
mot de passe ?aaa
Bonjour alice
Votre solde est de 123
Opération
- r : retrait
- q : quitter
> r
Combien ? 33
Votre solde est de 90
Opération
- r : retrait
- q : quitter
> r
Combien ? 10
Votre solde est de 80
Opération
- r : retrait
- q : quitter
> q
Au revoir, alice !
Autre utilisateur (o/n) ?o
Vous êtes    ? bob
mot de passe ?bbb
Bonjour bob
Votre solde est de 456
Opération
- r : retrait
- q : quitter
> r
Combien ? 23
Votre solde est de 433
Opération
- r : retrait
- q : quitter
> q
Au revoir, bob !
Autre utilisateur (o/n) ?o
Vous êtes    ? alice
mot de passe ?aaa
Bonjour alice
Votre solde est de 80
Opération
- r : retrait
- q : quitter
> 60
No comprendo
Votre solde est de 80
Opération
- r : retrait
- q : quitter
> r
Combien ? 60
Votre solde est de 20
Opération
- r : retrait
- q : quitter
> q
Au revoir, alice !
Autre utilisateur (o/n) ?n

-
Edité par michelbillaud 25 avril 2022 à 12:27:55