Discussion :

[adil1251985]

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;
}

[punx120]

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à

[3DArchi]

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++).

[adil1251985]

bonjour,
merci 3DArchi pour tes remarques, je vais essayer de simplifier mon code.

[adil1251985]

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");
}