conversion de string en int, cela n'a pas l'air de fonctionner

**EricStib** · 23/02/2009, 01h39

Bonjour à tous,

Dans la FAQ C++, j'ai trouvé ceci pour transformé un objet string en int:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
#include <sstream>
 
int main()
{
    // créer un flux à partir de la chaîne à convertir
    std::istringstream iss( "10" );
    // convertir en un int
    int nombre;
    iss >> nombre; // nombre vaut 10
}

J'essaie de transformer, pour ma part, un objet string en uint64_t mais cela ne fonctionne pas

Et je n'arrive (pas encore) à comprendre pourquoi cela ne fonctionne pas !

Si vous pouviez me mettre le nez sur mon erreur afin que je sache où chercher, je vous en serais reconnaissant.
a+

Voiçi mon code:

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
 
#include <iostream>
#include <fstream>
#include <stdint.h>
#include <vector>
#include <sstream>
#include <string>
/*
    Problem 13
    22 March 2002
 
    Work out the first ten digits of the sum of the following one-hundred
    50-digit numbers.
    
*/
 
using namespace std;
 
typedef uint64_t u64 ;
 
 
int main()
{
    const int LIGNE = 100 ;
    vector<u64> tab(LIGNE) ;
 
 
    // ouverture du fichier contenant les chiffres
    ifstream gridFile("chiffres.txt") ;
 
    // lire une ligne et la mettre dans une string
    string line ;
    while (getline(gridFile, line))
    {
        // convertir la string en u64 et le mettre dans un vector
        //
        // créer un flux à partir de la chaîne à convertir
        istringstream iss( line );
        // convertir en un u64
        u64 nombre ;
        iss >> nombre;
        // ajout dans le vector
        tab.push_back(nombre) ;
    }
 
	// la somme du contenu du tableau
	u64 som = 0 ;
	for (int i = 0; i < LIGNE; i++)
	{
		som += tab[i];
	}
    cout << som << endl ;
 
    return 0;
}

Je joins le fichier texte.

**dtrosset** · 23/02/2009, 09h39

Bonjour,

u_int64 est un entier non signé codé sur 64 bits. Sa valeur maximale est de 2^64-1, soit environ 16 milliards de milliards. Ce qui correspond en gros à 19 chiffres décimaux. Ceux du fichier en ont bien plus !

Il faut te tourner vers l'utilisation d'une librairie qui gère les grands nombres.

Didier

**EricStib** · 23/02/2009, 11h04

Bonjour et merci !!

Tu avais tout à fait raison... je ne regardais pas le problème dans le bon sens

L'utilisation d'un bibliothèque BigInt à résolu (et surtout simplifié) le code.

Un tout grand merci pour m'avoir aérer l'esprit

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
#include <iostream>
#include <fstream>
#include "bigint.h"
#include <string>
/*
    Problem 13
    22 March 2002
 
    Work out the first ten digits of the sum of the following one-hundred
    50-digit numbers.
   
*/
 
using namespace std;
 
typedef BigInt bInt ;
 
 
int main()
{
    bInt som ;
 
    // ouverture du fichier contenant les chiffres
    ifstream gridFile("chiffres.txt") ;
 
    // lire une ligne et la mettre dans une string
    string line ;
    while (getline(gridFile, line))
    {
        som += line ;
    }
 
    cout << som << endl ;
 
 
 
    return 0;
}

Voiçi le bigint.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
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
#include <vector>
#include <string>
#include <ostream>
 
struct Resultat;
 
class BigInt
{
 
public:
 
//CONSTRUCTEURS ----------------------------------------------------------------
 
BigInt(int n=0);
BigInt(std::string chaine);
 
// FONCTIONS MEMBRES SIMPLES ---------------------------------------------------
 
unsigned int longueur() const; //La longueur du nombre
bool getsigne() const; //Le signe sous forme de boolene
BigInt abs() const; //Renvoit la valeur absolue
 
//ACCES AUX CHIFFRES -----------------------------------------------------------
 
short int& operator[](unsigned int i);
const short int& operator[](unsigned int i) const;
short int& at(unsigned int i);
const short int& at(unsigned int i) const;
 
//OPPOSE -----------------------------------------------------------------------
 
BigInt operator-() const;
 
//OPERATEURS ARITHMETIQUES -----------------------------------------------------
 
BigInt& operator+=(const BigInt&);
BigInt& operator-=(const BigInt&);
BigInt& operator*=(const BigInt&);
BigInt& operator/=(const BigInt&);
BigInt& operator^=(int n);
BigInt& operator%=(const BigInt&);
 
//OPERATEURS D'INCREMENTATION --------------------------------------------------
 
BigInt& operator++(); //Incrémente de 1
BigInt operator++(int);
BigInt& operator--();
BigInt operator--(int);
 
private:
 
// FONCTIONS ASSISTANTES -------------------------------------------------------
 
void addition(const BigInt&); //Additione deux nombres de meme signe
void soustraction(const BigInt&autre); //Effectue la soustraction *this - autre si |*this| > |autre|
friend Resultat division(BigInt dividende, BigInt diviseur); //Effectue la division dividende/diviseur et renvoit
//Une structure de type Resultat avec le quotient et le reste
 
BigInt& multiplication_10n(int n); //Multiplie le BigInt par 10^n
BigInt(std::vector<short int> v); //Constructeur a partir d'un vector<>. Cree un nombre positif
std::vector<short int> getVecteur() const; //Renvoit le tableau m_chiffres
 
void supprimer_zeros(); //Supprime les zeros en tete du nombre
void zero(); //Met le BigInt a 0
 
//ATTRIBUTS --------------------------------------------------------------------
 
std::vector<short int> m_chiffres; //Les differents chiffres du nombre
bool m_signe; //true si le BigInt >=0
 
};
 
//PETITE STRUCTURE POUR LES DIVISIONS ------------------------------------------
 
struct Resultat
{
BigInt quotient;
BigInt reste;
};
 
// OPERATEURS D'ECRITURE DANS LES FLUX ----------------------------------------
 
std::ostream& operator<<(std::ostream& flux, const BigInt& n);
 
//OPERATEURS DE COMPARAISON-----------------------------------------------------
 
bool operator==(const BigInt& a,const BigInt& b);
bool operator!=(const BigInt& a,const BigInt& b);
bool operator<=(const BigInt& a,const BigInt& b);
bool operator>=(const BigInt& a,const BigInt& b);
bool operator<(const BigInt& a,const BigInt& b);
bool operator>(const BigInt& a,const BigInt& b);
 
//OPERATEURS ARITHMETIQUES EXTERNES --------------------------------------------
 
BigInt operator+(const BigInt& a,const BigInt& b);
BigInt operator-(const BigInt& a,const BigInt& b);
BigInt operator*(const BigInt& a,const BigInt& b);
BigInt operator/(const BigInt& a,const BigInt& b);
BigInt operator^(const BigInt& a,int n);
BigInt operator%(const BigInt& a,const BigInt& b);
 
//FONCTIONS MATHEMATIQUES USUELLES ---------------------------------------------
 
BigInt abs(const BigInt& n); //Valeur absolue
BigInt signe(const BigInt n); //Fonction signe

Et le bigint.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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
#include <cstdlib> //Pour abs()
#include <iostream>
#include "bigint.h"
 
using namespace std;
 
//CONSTRUCTEURS ----------------------------------------------------------------
 
BigInt::BigInt(int n)
:m_chiffres(0),m_signe(true)
{
//On sauvegarde le signe
m_signe = n>=0;
n=std::abs(n);
 
//Si c'est zero
if (n==0)
{
zero();
return;
}
 
//Sinon, on stocke les chiffres dans le vector dans l'ordre inverse
while (n>0)
{
m_chiffres.push_back(n%10);
n/=10;
}
 
//Et on supprime les zeros en-tete du vector
supprimer_zeros();
}
 
BigInt::BigInt(string chaine)
:m_chiffres(0),m_signe(true)
{
//Si il y a un moins devant, on met un signe -
if (chaine[0]=='-')
{
m_signe=false;
chaine.erase(0,1);
}
 
//On stocke ensuite les chiffres dans le vector
for (int i(chaine.size()-1);i>=0;--i)
m_chiffres.push_back(chaine[i]-'0');
 
//Et on supprime les zeros en-tete du vector
supprimer_zeros();
}
 
// FONCTIONS MEMBRES SIMPLES ---------------------------------------------------
 
unsigned int BigInt::longueur() const
{
return m_chiffres.size();
}
 
bool BigInt::getsigne() const
{
return m_signe;
}
 
BigInt BigInt::abs() const
{
//On cree une copie de l'objet avec un signe positif et on la renvoit
BigInt retour(*this);
retour.m_signe = true;
return retour;
}
 
//ACCES AUX CHIFFRES -----------------------------------------------------------
 
short int& BigInt::operator[](unsigned int i)
{
//On renvoit la composante i du vector
return m_chiffres[i];
}
 
const short int& BigInt::operator[](unsigned int i) const
{
//idem
return m_chiffres[i];
}
 
short int& BigInt::at(unsigned int i)
{
//On renvoit la composante i du vector avec un test de validité
return m_chiffres.at(i);
}
 
const short int& BigInt::at(unsigned int i) const
{
//idem
return m_chiffres.at(i);
}
 
//OPPOSE -----------------------------------------------------------------------
 
BigInt BigInt::operator-() const
{
//On cree une copie de l'objet avec le signe oppose et on la renvoit
BigInt retour(*this);
retour.m_signe = !m_signe;
return retour;
}
 
//OPERATEURS ARITHMETIQUES -----------------------------------------------------
 
BigInt& BigInt::operator+=(const BigInt& autre)
{
if (m_signe == autre.m_signe)
addition(autre); //Addition de type primaire
 
else if (abs() >= autre.abs())
soustraction(autre);//Soustraction de type primaire
else
operator=(autre+(*this)); //Inversion de a et b
 
return *this;
}
 
BigInt& BigInt::operator-=(const BigInt& autre)
{
//Effectuer a-b revient a faire a+(-b)
operator+=(-autre);
return *this;
}
 
BigInt& BigInt::operator*=(const BigInt& autre)
{
BigInt backup(*this);
zero();
 
for (unsigned int i(0);i<autre.longueur();++i)
{
BigInt temp(backup);
 
int retenue(0);
for (unsigned int j(0);j<temp.longueur();++j)
{
if (((temp[j] *= autre[i])+=retenue) >= 10)
{
retenue = temp[j]/10;
temp[j]%=10;
}
else
retenue =0;
}
if (retenue)
temp.m_chiffres.push_back(retenue);
 
temp.multiplication_10n(i);
operator+=(temp);
}
 
m_signe = backup.m_signe == autre.m_signe;
supprimer_zeros();
 
return *this;
}
 
BigInt& BigInt::operator/=(const BigInt& autre)
{
operator=(division(*this,autre).quotient);
return *this;
}
 
BigInt& BigInt::operator%=(const BigInt& autre)
{
operator=(division(*this,autre).reste);
return *this;
}
 
BigInt& BigInt::operator^=(int n)
{
if (n<0)
zero();
else
{
BigInt a(*this);
operator=(1);
for (int i(0); i<n;++i)
{
operator*=(a);
}
}
return *this;
}
 
//OPERATEURS D'INCREMENTATION --------------------------------------------------
 
BigInt& BigInt::operator++()
{
return operator+=(1);
}
 
BigInt BigInt::operator++(int)
{
BigInt ans = *this;
operator+=(1);
return ans;
}
 
BigInt& BigInt::operator--()
{
return operator-=(1);
}
 
BigInt BigInt::operator--(int)
{
BigInt ans = *this;
operator-=(1);
return ans;
}
 
// FONCTIONS ASSISTANTES -------------------------------------------------------
 
void BigInt::addition(const BigInt& autre)
{
unsigned int l(longueur() < autre.longueur() ? longueur() : autre.longueur());
int retenue(0);
 
for (unsigned int i(0);i<l;++i)
{
if ((m_chiffres[i] += autre[i] + retenue) >=10)
{
m_chiffres[i] %=10;
retenue =1;
}
else
retenue =0;
}
 
if (longueur() > autre.longueur())
for (unsigned int i(l);i<longueur();++i)
{
if ((m_chiffres[i]+= retenue) >=10)
{
m_chiffres[i] %=10;
retenue =1;
}
else
{
retenue =0;
}
}
 
else if (autre.longueur() > longueur())
for (unsigned int i(l);i<autre.longueur();++i)
{
if ((autre[i] + retenue) >=10)
{
m_chiffres.push_back((retenue+autre[i])%10);
retenue =1;
}
else
{
m_chiffres.push_back(autre[i]+retenue);
retenue =0;
}
}
 
if (retenue!=0)
{
m_chiffres.push_back(1);
}
}
 
 
void BigInt::soustraction(const BigInt& autre)
{
int l(autre.longueur());
 
int retenue(0);
for (int i(0);i<l;++i)
{
if ((m_chiffres[i]-= (autre[i]+retenue)) <0)
{
m_chiffres[i] = (m_chiffres[i] +10)%10;
retenue = 1;
}
else
retenue =0;
}
 
while (retenue!=0)
{
if ((m_chiffres[l]-=1) <0)
{
m_chiffres[l] = (m_chiffres[l] +10)%10;
retenue =1;
++l;
}
else
retenue =0;
}
 
supprimer_zeros();
 
}
 
 
BigInt& BigInt::multiplication_10n(int n)
{
m_chiffres.insert(m_chiffres.begin(),n,0);
return *this;
}
 
BigInt::BigInt(std::vector<short int> v)
:m_chiffres(v), m_signe(true)
{
supprimer_zeros();
}
 
std::vector<short int> BigInt::getVecteur() const
{
return m_chiffres;
}
 
void BigInt::supprimer_zeros()
{
int i(longueur()-1);
while (i>=1 && m_chiffres[i] ==0)
{
m_chiffres.pop_back();
--i;
}
if (i==0 && m_chiffres[i]==0)
zero();
}
 
void BigInt::zero()
{
m_signe = true;
m_chiffres.clear();
m_chiffres.push_back(0);
}
 
// OPERATEURS DE LECTURE ET ECRITURE DANS LES FLUX -----------------------------
 
ostream& operator<<(ostream& flux,const BigInt& n)
{
if (!n.getsigne())
flux << "-";
for (int i(n.longueur()-1);i>=0;--i)
flux << n[i];
return flux;
}
 
 
//OPERATEURS DE COMPARAISON-----------------------------------------------------
 
bool operator==(const BigInt& a,const BigInt& b)
{
if (a.getsigne() == b.getsigne()) //si a et b ont le meme signe
{
if (a.longueur() == b.longueur()) //qu'ils ont la meme longueur
{
for (unsigned int i(0);i<a.longueur();++i) //et qu'ils ont aucun chiffre different
if (a[i] != b[i])
return false; //Si il y a un différent on renvoit false
return true; //alors ils sont égaux
}
}
return false; //sinon ils sont differents
}
 
bool operator!=(const BigInt& a, const BigInt& b)
{
return !operator==(a,b);
}
 
bool operator<=(const BigInt& a,const BigInt& b)
{
if (!a.getsigne() && b.getsigne()) //a negatif et b positif
return true;
else if (a.getsigne() && !b.getsigne()) //a positif et b negatif
return false;
else //a et b de meme signe
{
if (a.longueur() < b.longueur()) //si la longueur de a et plus petite que b
return a.getsigne(); //ce sera vrai si a est positif et faux sinon
 
else if (a.longueur() > b.longueur()) //si a est plus long que b
return !a.getsigne(); //ce sera vrai si a est négatif
 
else //si ils ont la meme longueur
{
for (int i(a.longueur()-1);i>=0;--i) //on cherche le premier chiffre de a plus grand que b
if (a[i] > b[i]) //si il y en a un
return !a.getsigne(); //le test est vrai si a est negatif et faux sinon
else if (a[i] < b[i])
return a.getsigne();
}
 
}
return true;
}
 
bool operator>=(const BigInt& a,const BigInt& b)
{
return operator<=(b,a);
}
 
bool operator>(const BigInt& a,const BigInt& b)
{
return !operator<=(a,b);
}
 
bool operator<(const BigInt& a,const BigInt& b)
{
return !operator>=(a,b);
}
 
//OPERATEURS ARITHMETIQUES EXTERNES --------------------------------------------
 
BigInt operator+(const BigInt& a,const BigInt& b)
{
BigInt retour(a);
return retour+=b;
}
 
BigInt operator-(const BigInt& a,const BigInt& b)
{
BigInt retour(a);
return retour-=b;
}
 
BigInt operator*(const BigInt& a,const BigInt& b)
{
BigInt retour(a);
return retour*=b;
}
 
BigInt operator/(const BigInt& a,const BigInt& b)
{
return division(a,b).quotient;
}
 
BigInt operator%(const BigInt& a,const BigInt& b)
{
return division(a,b).reste;
}
 
BigInt operator^(const BigInt& a,int n)
{
BigInt retour(a);
return retour^=n;
}
 
Resultat division(BigInt dividende, BigInt diviseur)
{
Resultat r;
 
//On traite le cas ou |diviseur| > |dividende|
if (diviseur.abs() > dividende.abs())
{
r.quotient.zero();
r.reste = dividende;
r.reste.m_signe = dividende.m_signe;
return r;
}
 
//On traite le cas de la division par zero
if (diviseur.abs()==0)
return r;
 
//A partir d'ici, on est dans un cas normal
 
//On cree une table de toutes les multiplications du diviseur
vector<BigInt> tableau;
for (int i(0);i<=10;++i)
tableau.push_back(i*(diviseur.abs()));
 
//On cree un tableau pour le quotient
vector<short int> quotient;
 
//On cree un tableau avec les premiers chiffres du dividende
std::vector<short int> temp(diviseur.longueur());
for (unsigned int i(1);i<=temp.size();++i)
temp[temp.size()-i] = dividende[dividende.longueur()-i];
 
//Le nombre de chiffres descendus
unsigned int nbr_descendu(temp.size());
 
do
{
//Si le tableau n'est pas assez grand, on ajoute le chiffre suivant
if (BigInt(temp)< diviseur.abs())
{
temp.insert(temp.begin(),dividende[dividende.longueur()-nbr_descendu-1]);
++nbr_descendu;
}
 
//On cherche le multiple i du diviseur le plus grand que l'on peut mettre dans temp
int i(0);
while ((BigInt(temp) >= tableau[i]))
{
++i;
}
if (i>0)
--i;
 
//On ajoute i au quotient
quotient.insert(quotient.begin(),i);
 
//Et on effectue la soustraction
temp = (BigInt(temp)-= tableau[i]).getVecteur();
 
//On recommence tant qu'on a pas descendu tous les chiffres
}
while (nbr_descendu < dividende.longueur());
 
//On sauve le quotient et le reste
r.quotient = quotient;
r.reste = temp;
 
//Et on gere les signes
r.quotient.m_signe = dividende.m_signe == diviseur.m_signe;
 
if (r.reste.abs() == 0)
r.reste.zero();
else
r.reste.m_signe = dividende.m_signe;
 
return r;
}
 
 
//FONCTIONS MATHEMATIQUES USUELLES ---------------------------------------------
 
BigInt abs(const BigInt& n)
{
return n.abs();
}
 
BigInt signe(const BigInt n)
{
return n.getsigne() ? 1: -1;
}

conversion de string en int, cela n'a pas l'air de fonctionner

C++

Vue hybride

Discussions similaires

Partager

Partager