Newsgroup: it.comp.lang.c
Titolo: problema con atof

void main(){
	char	buffer[100]		=	{''};
	sprintf(buffer, "000142154508258.30");
	printf("nHai inserito %s = %f", buffer2, atof(buffer2));
}
da come risultato :
Hai inserito 000142154508258.30 = 142154508258.299990
Se invece sostituisco al terzo statement:
printf("nHai inserito %s = %.2f", buffer, atof(buffer));
allora ovviamente ottengo quello che avrei sperato:
Hai inserito 000142154508258.30 = 142154508258.30
Come posso risolvere questo baco di atof se non conosco in anticipo 
(come in questo caso)la precisione del numero rappresentato in buffer?
Quello che voglio essenzialmente fare e` assegnare ad un double il 
risultato di una atof (o chi per lei) ma senza modificare il numero che 
e` rappresentato nel buffer di caratteri, a prescindere dalla 
rappresentazione a mantissa e caratteristica tipica dello standard IEEE 
754/85 che ritengo sia la responsabile del danno. :-)
Esiste un trucchetto per aggirare il problema?
Grazie a tutti.

void main(){
 	char	buffer[100]		=	{''};
 	sprintf(buffer, "000142154508258.30");
 	printf("nHai inserito %s = %f", buffer, atof(buffer));
 }
 
 da come risultato :
 
 Hai inserito 000142154508258.30 = 142154508258.299990
 
 Se invece sostituisco al terzo statement:
 
 printf("nHai inserito %s = %.2f", buffer, atof(buffer));
 
 allora ovviamente ottengo quello che avrei sperato:
 
 Hai inserito 000142154508258.30 = 142154508258.30
 
 
 Come posso risolvere questo baco di atof se non conosco in anticipo 
 (come in questo caso)la precisione del numero rappresentato in buffer?
 
 Quello che voglio essenzialmente fare e` assegnare ad un double il 
 risultato di una atof (o chi per lei) ma senza modificare il numero che 
 e` rappresentato nel buffer di caratteri, a prescindere dalla 
 rappresentazione a mantissa e caratteristica tipica dello standard IEEE 
 754/85 che ritengo sia la responsabile del danno. :-)
 
 Esiste un trucchetto per aggirare il problema?
 
 Grazie a tutti.
 
Alessio

 754/85 che ritengo sia la responsabile del danno. :-)
scusa, ma come puoi assegnare un valore ad un double prescindendo
dal formato standard del double ??
In ogni caso e' importante che tu capisca che atof non ha modificato
il numero che gli hai passato, semplicemente lo ha rappresentato
con il double piu' prossimo. Il fatto e' che in binario non puoi
rappresentare esattamente la maggior parte dei numeri decimali.
Per esempio 0.3 non e' rappresentabile in modo esatto con un double.
Il tuo problema lo puoi risolvere in molti modi:
1) non usi i double ma una tua rappresentazione tipo quella in cui ogni 
cifra decimale si rappresenta in un nibble.
Chiaramente poi le operazioni vanno implementate ad hoc.
2) quando leggi un numero ti memorizzi anche il numero delle cifre
significative dopo la virgola e usi quel numero per le
stampe successive. Tipo se leggi 123.456 ti memorizzi che ci sono 3 
decimali e quindi quando lo stampi usi 3 decimali. In questo modo
riottieni il numero di partenza (anche se internamente non sara'
mai uguale esattamente a 123.456)
3) crei una routine che cerca di indovinare il numero di cifre
significative decimali di un numero.
Questo puo' essere fatto stampando in un buffer il numero con
molti decimali e poi andando a cercare sequenze di 9 o di 0
e approssimando opportunamente.
Per esempio se x corrisponde a 123.455999999999999257 o a
123.456000000000000453 puoi ragionevolmente assumere che il
numero di partenza fosse 123.456 e quindi scartare i decimali
aggiunti.
ciao,
g.