IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage C++ Discussion :

[Langage] Manipulation de nombres


Sujet :

Langage C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Inscrit en
    Février 2007
    Messages
    13
    Détails du profil
    Informations forums :
    Inscription : Février 2007
    Messages : 13
    Par défaut [Langage] Manipulation de nombres
    salut tout le monde, je suis entrain de developper un programme qui calcule le produit de deux grands nombres,

    pour cela j'ai pas travaillé avec des int mais plutot avec des string (chaine de caraccteres).
    je pense qu'au niveau de conception y a pas de probleme .
    alors mon probleme se manifest au cas où je tape un grand nombre pour le premier argument (exp 222222) le programme sort son afficher acun resultat.

    voila mon code



    gichier .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
     
    #ifndef _BIGINT_
    #define _BIGINT_
     
    #include <string>
    #include <iostream>
     
    using namespace std; 
     
    class BigInt {
     
          public:
                 string number; // variable de type string pour maniupler les grands chiffres
                 BigInt(){}; // constructeur par defaut
                 BigInt(string s); // constructeur aves un argument de type string 
                 friend ostream& operator<<(ostream&, const BigInt&); // surcharge de l'operateur " << " 
                 friend istream& operator>>(istream&, BigInt&); // surcharge de l'operateur " << "
                 friend BigInt operator +(BigInt bUn , BigInt bDeux); // surcharge de l'operateur " + "
                 friend BigInt operator -(BigInt bUn , BigInt bDeux); // surcharge de l'operateur " - "
                 friend BigInt calculerMulti(BigInt , BigInt); // fonction amie pour calculer la multiplication 
                 int getnumber(string); // fonction membre qui retourne le nombre de chiffre dans le nombre
                 };
    #endif
    fichier .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
     
    #include <iostream>
    #include <stdlib.h>
    #include "bigInt.h"
    #include <sstream>
    #include <conio.h>
     
        BigInt::BigInt(string s){
                number = s ;    
        }
     
        ostream& operator <<(ostream& out, const BigInt& b){
               out << b.number ;
               return out;
        }
     
        istream& operator >>(istream& in, BigInt& b){
              in >> b.number;
              return in;
        }
     
        BigInt operator +(BigInt bUn,BigInt bDeux){
                BigInt resultatF;
                int TbUn,TbDeux,retenu=0,compteur=0,aide1,aide2,resultat;
                string s1,s2;
                s1 = bUn.number;
                s2 = bDeux.number;
                TbUn = s1.length();
                TbDeux = s2.length();
                // créer un flux de sortie
                ostringstream oss; 
                       if (TbUn>TbDeux)
                       {
                          for(int r=0; r<(TbUn-TbDeux); r++){
                          s2 = "0" + s2;
                          }
                       }
                       else
                       {
                           for(int r=0; r<(TbDeux-TbUn); r++){
                           s1 = "0" + s1;
                           }
                       }
     
                TbUn = s1.length();
                char *tab1 = (char *)s1.c_str();
                char *tab2 = (char *)s2.c_str();
                int tabResultat[TbUn];      
                       for(int j=TbUn-1; j>=0; j--)
                       {
                               aide1 = (int)(tab1[j]-'0');
                               aide2 = (int)(tab2[j]-'0');
                               resultat = aide1 + aide2 + retenu;
                               if (resultat>=10 && j!=0) 
                               {resultat = resultat-10;retenu = 1;}
                               else retenu = 0;
                               tabResultat[compteur++]= resultat;    
                       }
     
                       for(int j=TbUn-1; j>=0; j--)
                       {oss << tabResultat[j];}            
                resultatF.number = oss.str();
                return(resultatF);
        }
     
        BigInt operator -(BigInt bUn , BigInt bDeux){
               BigInt resultatF;
               int TbUn,TbDeux,retenu=0,compteur=0,aide1,aide2,resultat;
               string s1,s2;
               bool TenZero;
               s1 = bUn.number;
               s2 = bDeux.number;
               TbUn = s1.length();
               TbDeux = s2.length();
               ostringstream oss; 
                       if (TbUn>TbDeux)
                       {
                          for(int r=0; r<(TbUn-TbDeux); r++){
                          s2 = "0" + s2;
                          }
                       }
                       else
     
                       {
                           for(int r=0; r<(TbDeux-TbUn); r++){
                           s1 = "0" + s1;
                           }
                       }
     
               TbUn = s1.length();
               char *tab1 = (char *)s1.c_str();
               char *tab2 = (char *)s2.c_str();
               int tabResultat[TbUn];      
                       for(int j=TbUn-1; j>=0; j--)
                       {
                              aide1 = (int)(tab1[j]-'0');
                              aide2 = (int)(tab2[j]-'0');
                              aide2 = aide2 + retenu;
                              if (aide1<aide2 )
                              {retenu = 1; resultat = (aide1+10) - aide2;}
                              else
                              {retenu = 0; resultat =  aide1 - aide2;}
                              tabResultat[compteur++]= resultat;  
                       }
     
                       for(int j=TbUn-1; j>=0; j--)
                       {
                                if (tabResultat[j]!=0)
                                {
                                TenZero = false;
                                break;
                                }
                                else 
                                {
                                TenZero = true;
                                }
                       }
     
                       for(int j=TbUn-1; j>=0; j--)
                       {oss << tabResultat[j];}            
     
               if (TenZero == false)
               {
                     resultatF.number = oss.str();
                }
               else 
               {
                     resultatF.number = "0";
               }
               return(resultatF);    
        }
     
        BigInt calculerMulti(BigInt bUn,BigInt bDeux){
               BigInt tempAide("1");
               BigInt aideCdeB("0");
               int nombreUn,nombreDeux;
               istringstream issUn(bUn.number);
               istringstream issDeux(bDeux.number);
               issUn >> nombreUn;
               issDeux >> nombreDeux;
               //if(bUn.number=="0" || bDeux.number=="0"){return aideCdeB;}              
               if(nombreUn==0 || nombreDeux==0){return aideCdeB;}
               else{return (bDeux+calculerMulti(bUn-tempAide,bDeux));}
        }
     
        int getnumber(string t){
                return t.length();
        }
    programme principal
    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
     
    #include <cstdlib>
    #include <iostream>
    #include <conio.h>
    #include <string>
    #include "bigInt.h" 
     
    using namespace std; 
     
    int main()
    {
        BigInt nbrUn;
        BigInt nbrDeux;
        BigInt n;
     
        cout << "Tapez SVP le premier nombre = ";
        cin >> nbrUn;
        cout <<"Tapez SVP le dexieme nombre = ";
        cin >> nbrDeux;
        cout << calculerMulti(nbrUn,nbrDeux)<<endl;
        system("PAUSE");system("PAUSE");system("PAUSE");system("PAUSE");
        return EXIT_SUCCESS;
    }

  2. #2
    Membre averti
    Profil pro
    Inscrit en
    Janvier 2004
    Messages
    43
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Janvier 2004
    Messages : 43
    Par défaut
    Je ne comprends pas trop ce que tu veux faire dans ta méthode "calculerMulti".

    Mais lorsque bUn est "gros", tu va avoir autant d'appel récursif. Le problème vient peut être de là

  3. #3
    Rédacteur
    Avatar de 3DArchi
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    7 634
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 7 634
    Par défaut
    Bonjour,
    Quelques remarques:
    * Dans l'addition, tu déclares int tabResultat[TbUn]; Ne serait-ce pas plutôt int tabResultat[TbUn+1]; si tu as une dernière retenue?
    * Ton calcul de retenu me parait tortueux:quelque chose de plus simple:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    retenu = resultat/10; //division entière!
    tabResultat[compteur++]= resultat%10;// modulo!
    * Tu répètes le code pour l'ajout des 0 à gauche, pourquoi ne pas le factoriser dans une même méthode?
    * Dans la soustraction, la boucle pour TenZero me paraît maladroite. Tu positionnes à true à chaque itération tant que tu ne sorts pas de la boucle. Quelque chose comme ça:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    TenZero = true;
    for(int j=TbUn-1; (j>=0)&&(TenZero); j--)
    {
       if (tabResultat[j]!=0)
       {
          TenZero = false;
       }
    }
    Note que tu pourrais carrément faire le tests dans la boucle précédente:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    tabResultat[compteur++]= resultat;  
    TenZero = TenZero & (resultat==0);
    * Dans calculerMulti: issUn >> nombreUn; si ta chaîne contient un entier > int alors nombreUn = 0 (avec VC++).

  4. #4
    Membre averti
    Inscrit en
    Février 2007
    Messages
    13
    Détails du profil
    Informations forums :
    Inscription : Février 2007
    Messages : 13
    Par défaut
    bonjour,
    merci 3DArchi pour tes remarques, je vais essayer de simplifier mon code.

  5. #5
    Membre averti
    Inscrit en
    Février 2007
    Messages
    13
    Détails du profil
    Informations forums :
    Inscription : Février 2007
    Messages : 13
    Par défaut
    apres l'etude de mon programme j'ai vu que le probleme vient de la surcharge de l'operateur "-"; pour cela j'ai créé une fonction recursive qui diminue le premier nombre par le deuxieme(=1) jusqu'a obtenir zero .
    question : pourquoi quand je tape un petit nombre la fonction s'a marche mais pour les grand nombre non.
    exemple : pour les nombres inférieur à 4189

    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
     
    #include <iostream>
    #include <string>
    #include <conio.h>
    #include <stdlib.h>
    #include <sstream>
     
    using namespace std;
     
    //fonction qui diminue le premier nombre par le deuxieme(=1) jusqu'a obtenir zero  
    string soustraction(string nbr1,string nbr2){
     
        int Tnbr1; // contient la taille du premier nombre 'nbr1' (nombre de chiffre)
     
        int retenu=0,compteur=0,aide1,aide2,resultat;
     
        string resultatF;
     
        ostringstream oss;// un flux de sortie
     
        Tnbr1= nbr1.length();
     
        char *tab1 = (char *)nbr1.c_str(); // creation d'un tableau de caracteres du 1er nombre 
     
        char *tab2 = (char *)nbr2.c_str(); // creation d'un tableau de caracteres du 2eme nombre
     
        int tabResultat[Tnbr1]; // declaration d'un tableau pour le resultat de la difference 
     
        bool TenZero=true; // un boolean pour tester si le resultat retourné contient que des zero 
     
        // boucle pour faire la difference entre les 2
        //nombres et cela caractere par caractere en comencant par le dernier
        for(int j=Tnbr1-1; j>=0; j--)  
        {
           aide1 = (int)(tab1[j]-'0');// conversion des caracteres du 1er nombre : char --> int
           aide2 = (int)(tab2[j]-'0');// conversion des caracteres du 2eme nombre : char --> int
           aide2 = aide2 + retenu;
                                      // gestion de la soustraction caractere(int) par caractere(int)
        if (aide1<aide2)
           {retenu = 1; resultat = (aide1+10) - aide2;}
        else
           {retenu = 0; resultat =  aide1 - aide2;}
     
        tabResultat[compteur++]= resultat;  // stockage du resultat dans le tableau " tabResultat "  
        } 
     
     
        //en comencant par le dernier on va empiler le flux 
        for(int j=Tnbr1-1; j>=0; j--)
        {oss << tabResultat[j];}            
     
        // extraire le resultat dans le flux sous le format string( cette fonction doit retournée string !!!)  
        resultatF=oss.str();
     
        //  boucle pour tester si le resultat retourné ne contient que des zero 
        for(int j=Tnbr1-1; (j>=0)&&(TenZero); j--)
        {
           if (tabResultat[j]!=0)
           {
              TenZero = false;
           }
        }
     
        // affecter au resultat final "0" si tabResultat ne contient que des zero
        // sert à sortir de l'appel recusif ' cas de base '
        if (TenZero == false){resultatF = oss.str();}
        else{resultatF = "0";}
     
        // affichage du resultat pour chaque appel 
        cout <<resultatF<<endl;
     
        if(resultatF=="0"){cout <<" Fin "<<endl; return "0";} // cas de base de la fonction recusive " soustraction( , ) "
        else{return soustraction(resultatF,nbr2);} 
    }
     
    main ()
    {
    string s1,s2="1";
    int i1,i2;
    cout << " Taper un nombre : " ;
    cin >> s1;
        i1= s1.length();
        i2= s2.length();
        if (i1>i2)
        {
            for(int r=0; r<(i1-i2); r++){
                 s2 = "0" + s2;
            }
        }
    cout <<"Lancer la soustraction    :   ";
    getch();
    cout <<endl<<soustraction(s1,s2)<<endl;
    system("pause");
    }

Discussions similaires

  1. Quel langage de programmation pour la manipulation de nombre extrêmement grand
    Par Lord - Nelson dans le forum Langages de programmation
    Réponses: 4
    Dernier message: 17/11/2014, 22h27
  2. Réponses: 1
    Dernier message: 17/03/2006, 22h23
  3. [langage] générer un nombre aléatoire gaussien
    Par kayari dans le forum Langage
    Réponses: 5
    Dernier message: 23/05/2005, 08h12
  4. [langage] manipulation de fichiers
    Par perleur dans le forum Langage
    Réponses: 5
    Dernier message: 03/01/2005, 16h33
  5. [langage] arrondir un nombre
    Par GMI3 dans le forum Langage
    Réponses: 4
    Dernier message: 24/06/2004, 11h18

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo