Newsgroup: it.comp.lang.c++
Titolo: std::string -> float

C'è un modo standard per convertire direttamente una
std:: string in un float?
al momento io faccio
std::string stringa;
float x;
x = atof(stringa.c_str());
ma mi sembra di fare il giro dell'oca...
esiste un modo migliore?
grazie
Gerolamo

 std:: string in un float?
Eccoti un semplice esempio:
#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
using namespace std;
int main()
{
    string s( "123.4567" );
    cout << s << endl;
    istringstream iss( s );
    float f;
    iss >> f;
    cout << setprecision( 7 ) << f << endl;
}
EMG

> > C'è un modo standard per convertire direttamente una

prima di tutto grazie.
...sembra "molto C++", soprattutto tispetto al mio...
...però mi da anche qui l'impressione di fare un giro inutile, mah...
ne deduco che non esiste una maniera per farlo in una botta sola.
Giusto?
Gerolamo


float f=atof(str.c_str());
Non capisco perchè ti abbiano risposto con 6-7 linee di codice...
Luc.

Non capisco perchč ti abbiano risposto con 6-7 linee di codice...
Perche' questo ng si chiama it.comp.lang.c++ ed e' bene illustrare
come questa operazione si fa in C++.
--
Andrea Laforgia (ICQ 87230455)
------------------------------ 
#exclude <windows.h>

come questa operazione si fa in C++.
Ma anche ciò che ho scritto io (enormemente più comodo) è compilabile
solo in C++ 8-)
PS: Secondo me chi ha chiesto questa informazione userà la soluzione
da me proposta, ho questo sospetto... 
Luc.

da me proposta, ho questo sospetto... 
Bravo, che vuoi che ti dica ?


Bravo, che vuoi che ti dica ?
Bravo è sufficiente 8D

 da me proposta, ho questo sospetto...
Peccato, perche' imparerebbe di piu' usando l'altro...
Ciao,
Nicola

Comunque ora è libero di poter scegliere ;)
Se vuole imparare, deve scegliere la versione di EMG.


ne deduco che non esiste una maniera per farlo in una botta sola.
Puoi scriverti una funzione in C++ che ti esegue la stessa operazione
di atof(), ma che accetta una stringa, anziche' un vettore di
caratteri.


 Giusto?


Mi sfugge qualcosa. Facendo taglia e incolla dal messaggio che ha generato
il thread:
"al momento io faccio
std::string stringa;
float x;
x = atof(stringa.c_str());
ma mi sembra di fare il giro dell'oca..."
Ora lui ti chiede di farlo in maniera diversa e tu gli rispondi:
float f=atof(str.c_str());
???

 Luc.
Gerolamo

 veloce (se non di piu') di quello che usa la libreria standard del C.
Lasciando perdere che un metodo è "più C" e l' altro "più C++",
quale usereste?
Grazie a tutti per la risposta.
Gerolamo

Peccato, perche' imparerebbe di piu' usando l'altro...
Qui non sono d'accordo. Se si vuole imparare che e' possibile avere
uno stream di input da una stringa allora ok, questo e' buono;
se si vuole dire che il sistema migliore per convertire una stringa
in float e' passare attraverso std::istringstream allora proprio
non posso condividere.
Sicuramente andrebbe aggiunto un po' di contesto ... ma considerando
il problema come avulso (ovvero ti passo una std::string e ne voglio
avere il valore float, liberta' su quanto non detto) usare
std::istringstream mi sembra fuori luogo.
Si ha una *vaga* idea di quante cose tirano in ballo quelle banali
istruzioni proposte da EMG ?
Giusto per aiutare a rendersi conto la versione std::istringstream
e' (con il BCC55, opzioni di default) circa 89 (diconsi ottantanove)
volte piu' lenta.
Imparare ad usare std::istringstream quando si desidera atof e' a
mio parere un passo deciso nella direzione sbagliata.
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

mio parere un passo deciso nella direzione sbagliata.
Il problema e' che NON si desidera atof.
Il nostro amico atof lo usa gia', ma non e' soddisfatto.


 Il nostro amico atof lo usa gia', ma non e' soddisfatto.
Veramente nel posting originale non ho trovato nessun
astio nei confronti di atof(). Veniva semplicemente chiesto
se esistesse qualcosa di piu' diretto.
La risposta e' "purtroppo no". In particolare la soluzione
istringstream e' decisamente meno diretta di atof e, ad un
costo esorbitante, offre il solo pregio (se pregio si puo'
chiamare) di rendere poco chiaro cosa si sta cercando di
fare (ovvero convertire una stringa ascii in float, il
lavoro di atof --> "ascii to float").
Fra l'altro non credere che l'uso di atoi(s.c_str) sia una
cosa "brutta". In "The C++ Programming Language" terza edizione
Bjarne Stroustrup mostra fra gli esempi di casi in cui l'uso
di c_str si rivela molto utile la seguente funzione:
    extern "C" int atoi(const char *s);
    int atoi(const std::string s)
    {
      return atoi(s.c_str());
    }
e consiglia semplicemente di incapsulare questi usi diretti
della rappresentazione c_str() in apposite funzioni di alto
livello (cito a memoria, perdonate eventuali differenze).
Non credo che qualcuno con i piedi per terra potrebbe seriamente
consigliare di usare istringstream per fare questo lavoro.
Andrea
----------------------------------------------------------------
 <\___/>  Andrea        email: agriff at tin dot it
 / . . \  "6502"          irc: _6502_@EFNET#italia
(  (")  ) Griffini   homepage: 
http://www.netservers.com/~agriff
Sent via Deja.com 
http://www.deja.com/
Before you buy.

 wrote in message news:8qqaqm$k2u$1...@nnrp1.deja.com...


Andrea
Grande, con una frase hai espresso tutto il mio pensiero. 8-)))
Luc.

Il nostro amico atof lo usa gia', ma non e' soddisfatto.
Non è soddisfatto perchè gli sembra 'arrovellato', figurati con gli
stream 8-P
Luc.


E' sfuggito qualcosa anche a me ;)
Luc.

Perche', a mio avviso correttamente, la conversione di una stringa in
tutti i tipi possibili immaginabili, anche se built-in, non e'
considerata una funzionalita' propria della classe stringa.
c_str() e' un discorso diverso, perche' nessuna classe stringa puo'
pensare di imporsi in C++ senza fornire un meccanismo di conversione
verso le stringhe C.
Il meccanismo di conversione generale e' quello basato su stream,
type-safe ed estensibile, ma come giustamente fa notare Andrea,
pesantuccio.
Ciao,
Nicola

consigliare di usare istringstream per fare questo lavoro.
Be', prima che andasse via, lo consigliava sempre Alex Martelli.
Non so se lo conosci, ma e' uno che i piedi ce l'ha /veramente/ per
terra ;)


(Non c'entra molto con la linea di discussione presa dal thread,
ma...)
Non capisco perche' tutti parlino di atof ed a nessuno sia venuta in
mente strtod; almeno permette di capire se la string contiene
caratteri illegali.  Io in genere scrivo cose del tipo:
char *pc;
x = strtod(string, &pc);
if (!isspace(*pc) && *pc != '\0') { /* input error */ }
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

di EMG?
Si'.


mente strtod;
Immagino che l'esistenza della arcinota atoi porti a non cercare
alternative... :(
Riprendendo il thread, vorrei invece esplicitare qualche mio pensiero:
a) Non sempre il C++ offre una soluzione migliore di quella C, 
     in effetti in questo caso sembra che la classe string non offre
     (dispone di un)  supporto adeguato ed *immediato*. D'altronde
     il C++ e` lontano da essere un linguaggio perfetto, come
     d'altronde il C
b) Se pero` la stringa e` in realta` una sequenza di token da
interpretare, l'uso di stringstream e` una grande comodita`
(ve lo assicuro perche` ho usato tale stratagemma per un
piccolo interprete).
c) potrebbe (in generale) bastare rivedere il problema in modo diverso
perche`  il problema sparisca!
Paolo
-------------------------------------------
  Paolo Marotta
 
http://web.tiscalinet.it/paolo_marotta/
-------------------------------------------