Newsgroup: it.comp.lang.c++
Titolo: int 2 string

 Avrei lo stesso problema anche con i tipi del VC++ come CString.
Mumble. Non e' molto IT. E non e' neppure molto C++. Anzi: e' molto piu' C che
non C++. Pero' puoi usare CStringT::Format e CStringT::AppendFormat.
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

C'è un modo per scrivere direttamente un intero in una string ?
Per  adesso uso sprintf con un char* e poi costruisco la stringa, ma non si
può fare direttamente ?


 non C++. Pero' puoi usare CStringT::Format e CStringT::AppendFormat.
Cstring è "C" ?
da quando ?
--
-------
sito: 
www.dadev.it
ultime: Ocx per irc testi freeware
-------

 da quando ?
Non CString ma sprintf. E le funzioni suddette non sono altro che una sprintf
... messa come membro. Sarebbe stato molto piu' nella filosofia C++ usare uno
stream. Come infatti avviene per le string.


 Avrei lo stesso problema anche con i tipi del VC++ come CString.
Mi dispiace ma non conosco le MFC.
Ciao
-- 
Abruzzo Silvio
studente, 16 anni
goku_...@libero.it
silvi...@aruba.it
^____^

Passa agli stream e scrivi direttamente sulla std::string.
Davvero la ritieni una soluzione ragionevole ?
Magari anche il contrario (usare streams per fare conversioni
stringa->intero) ?
A me sembrano cose orribili.
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 A me sembrano cose orribili.
Perche'? Posto che se gli stream sono implementati in modo inefficiente
la cosa puo' risultare praticamente inaccettabile, lo scopo fondamentale
delle classi stream e' proprio la conversione da e per sequenze di
caratteri, e non l'I/O. Piuttosto sono i nomi "stream" e "stream buffer"
che sono decisamente infelici.
Un'obiezione che invece mi pare ragionevole e' che la type safety e'
ottenuta a scapito della concisione: rispetto a quello che si puo' fare
con i formati di printf/scanf e compagnia, formattare output complesso
con gli stream richiede chilometri di codice.
Un altra obiezione che ho sentito fare e' che per scrivere codice
internazionalizzato sarebbe opportuno disaccoppiare, all'interno di una
stringa parametrizzata, l'ordine dei parametri come scritti nel codice
dall'ordine in cui compaiono in output, ad esempio per gestire lingue
con diversa costruzione. In ogni caso questo e' attualmente impossibile
con la libreria standard. Si puo' invece fare con la versione X/Open di
printf.
Ciao,
Nicola

 A me sembrano cose orribili.
Il tempo di conversione, se il compilatore e' decente, dovrebbe essere
paragonabile a quello di una sprintf; avevo fatto delle prove
scrivendo interi da uno ad un milione e gli stringstreams erano PIU'
VELOCI della sprintf (con g++ 2.95) - almeno se creavi lo stringstream
esternamente al loop e ci scrivevi ogni volta dopo averlo 'azzerato'.
Inoltre ci sono cose che si possono fare solo in questo modo in
maniera efficiente: ad esempio, tempo fa ho scritto una classe
templata che legge da file (quindi da una std::string) il valore da
assegnare ad una variabile di tipo T; in C++ basta scrivere
std::string s;  // rismpita opportunamente da una getline
std::istringstream is(s);
char c;
T t;
is >> t;
if (is.fail()   ||   ((c = is.peek()) != EOF   &&   c != ' ')) {
  // errore di conversione; la seconda parte controlla che dopo la
  // conversione si sia arrivati o a fine string, o ad uno spazio
  // (nel caso che la string non sia finita e ci siano altri valori
  // successivi da interpretare)
} else {
  // conversione OK
}
In C probabilmente la maniera piu' efficiente e' quella di costruire a
runtime la string di formato per sscanf a seconda di cosa e' T; e si
rimane coi soliti problemi 1) quando si vuole leggere un tipo T prima
non considerato bisogna riscrivere il codice 2) sscanf in quanto a
error checking non e' buona 3) codice poco comprensibile, mentre
quello di prima e' immediato da capire 4) ho dimenticato qualcosa :-?
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

 printf.
cosa e'?
Ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

printf.
Quello e' un grado di liberta' importante, almeno in
teoria; pero' devo dire che io per lavoro scrivo
software che deve andare in diverse lingue (normalmente
italiano, inglese, francese, portoghese e spagnolo)
e in realta' secondo me avere solo messaggi e stringhe
di formato su file esterno e' sufficiente nel 99% dei casi.
Piu' rognose sono le conversioni verso i sistemi di misura
anglosassoni (dove una lunghezza potrebbe essere scritta
come 2'5+43/64" quando da noi e' 754 mm) e per le date in
cui i campi possono assumere sequenze diverse.
In quei casi ho delle routine specifiche che utilizzano
dei miei formati.
In passato ho anche avuto brutte esperienze sul
supporto internazionale del C e del C++ (ho trovato
molti bug) e quindi ora tendo a riscrivermi le cose a
mano oppure a usare sotto windows le chiamate messe a
disposizione da Win32.
Resta il fatto che anche quella "poca" dinamicita'
delle stringhe di formato che tornava utile e che
era presente nell'I/O del C e' stata rimossa nel
sistema di I/O proposto dal C++.


}
Se per te non e' importante avere codice che gira minimo 10 volte
piu' lento di quanto potrebbe e che usa molte piu' risorse senza
reali motivi (allocazioni dinamiche) solo per risparmiare di
scrivere delle funzioni da una riga liberissimo.
Forse si tratta solo di implementazioni scarse. Pero' sono quello
che ho trovato in tre compilatori C++ su tre che ho a disposizione.



Se non ti piace che si effettui la copia della stringa basta implementare
un nuovo stream di input che legga da una stringa (è molto facile).
Saluti  Manlio Perillo

 cosa e'?
X/Open e' l'insieme di standard industriali che definiscono cos'e' un
sistema Unix. Il consorzio, che e' anche proprietario del trademark
Unix, e' diventato "The Open Group" qualche anno fa:
http://www.opengroup.org/
Ciao,
Nicola

un nuovo stream di input che legga da una stringa (è molto facile).
E' quello che faveva la classe pre-standard equivalente a
istringstream. E' anche uno degli esercizi proposti da
Stroustrup su "The C++ Programming Language".
Si tratta anche sicuramente di un esercizio interessante.
Se pero' uno facesse una cosa simile in un punto in cui
bastava scrivere atoi(s.c_str()) in un programma di cui
sono responsabile io ... beh ... credo che gli farei
mangiare il listato.
Cosa c'e' di brutto "atoi(s.c_str())" ? E' forse troppo
semplice e noi ci si deve complicare la vita a tutti i costi ?
Ovvio... l'uso di operator>> fa *molte* piu' cose: se quelle
servono non si discute. Ma se quelle non servono e' secondo
me assurdo complicarsi la vita (e pagare) senza motivo.
Io sono un tifoso di STL (o almeno di una buona parte) ...
ma quelli che hanno il ribrezzo delle funzioni che esistono
anche in C solo per il fatto che sono funzioni che esistono
*anche* in C mi incuriosiscono.


 semplice e noi ci si deve complicare la vita a tutti i costi ?
ma atoi non modificava la stringa di partenza o mi confondo con 
un'altra funzione?

se puo' essere utile a qualcuno...
oggi preso dalla noia ho scritto un parser per interi e per float.
vi posto solo la parte x il parse degli interi (che è necessaria anche x il
parse dei float):
#include "NumberParser.h"
#include <ctype.h>
#include <math.h>
int NumberParser::ParseChar(char c)
{
    if(isdigit(c))
        return (c - '0');
    else return -1;
}
int NumberParser::ParseInt(string s)
{
    int c = 0;
    for(int k = 0; k < s.length(); k++)
        if(isdigit(s.c_str()[k])) c++;
    if(c == s.length())
    {
        int intVal = 0;
        for(k = 0; k < c; k++)
            intVal += ParseChar(s.c_str()[k]) * pow(10, c - k - 1);
        return intVal;
    }
    return -1;
}
l'ho scritta per passare il tempo. niente di serio e non so come va a
prestazioni. se qualcuno ci si vuole divertire...
ciao :: xaero



prestazioni. se qualcuno ci si vuole divertire...
Spero che tu non te la prenda... ma a me sembra orribile.
Perche' usare pow quando basta moltiplicare per 10 ?
Perche' fare una prima passata ?
Io proporrei le piu' semplice...
   #include <ctype.h>
   int my_atoi(const char *s)
   {
     while (isspace((unsigned char)*s))
       s++;
 
     bool neg = false;
     if (*s == '-')
     {
       neg = true; s++;
     }
 
     int acc = 0;
     while (*s>='0' && *s<='9')
     {
       acc = acc*10 + *s++ - '0';
     }
     return neg ? -acc : acc;


un'altra funzione?
Ti confondi. atoi legge solamente e restituisce
il numero intero contenuto (oppure zero se non si
tratta di un numero).


 tratta di un numero).
Il che mi pare gia' un motivo sufficiente per *non* usare atoi (il
codice d'errore nel codiminio della funzione ?!)
Ciao,
Nicola

    }
mi sono anche dimenticato la gestione dei numeri negativi...
ciao :: xaero

[...]
Perché non usi isdigit?
-- 
Marco Barisione (ICQ 84277092)

 Perché non usi isdigit?
Perche' tutti sono impegnati a scannarsi su rand() sul corretto uso
della lingua italiana, sulle differenze tra chat e newgroup etc etc.
-- 
Posted from [194.214.173.28] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

codice d'errore nel codiminio della funzione ?!)
Non e' un codice di errore. Nel suo contratto atoi dice che
torna zero se la stringa passata non contiene un numero
nella sua parte iniziale. L'unica condizione "anomala" non
gestita e' l'overflow (ma lo stesso vale per la somma di
interi, ad esempio).
Ci sono *altre* funzioni che valutano il numero e ti dicono
a che carattere si ferma l'analisi. Sono piu' sofisticate e
piu' scomode da chiamare... a volte e' comoda atoi a volte
sono necessarie queste altre (strtol/strtoul/strtod).


Perché non usi isdigit?
Giusta obiezione. Inizialmente non saltavo gli spazi
e quindi non avevo incluso nessun header. Poi ho visto
che atoi deve saltare gli spazi iniziali e quelli
sono noiosi da controllare esplicitamente.
isdigit sarebbe piu' leggibile (anche se non sposta
molto la cosa visto che alla riga successiva viene
usata l'aritmetica sui char e il fatto che le cifre
sono garantite essere consecutive).



Saluti   Manlio Perillo


Vabbe', vabbe', il mio era puro spirito di polemica :-) Comunque sono
d'accordo col discorso di non sparare alle zanzare col bazooka.
Volevo pero' segnalare un altro vantaggio delle tecniche specifiche C++,
ed e' che permettono di scrivere codice generico, a differenza delle
funzioni di derivazione C, che ovviamente non hanno overload.
Ciao,
Nicola

del C++ non ottimali.
Non fa differenza. Questo e' quello che passa il convento.
Se il programma che scrivi gira come una lumaca quando
viene compilato da quelli che credo siano i tre compilatori
C++ piu' diffusi al mondo non credo che tu possa liquidare
la cosa dicendo che e' solo colpa dei compilatori.
E' comunque colpa del programma che si aspetta troppo dai
compilatori attuali.
Ho visto codice molto interessante che con i template
fa miracoli (es. capire se una classe e' la derivata
di un'altra e altre cose utili).
Peccato che non sia riuscito a vedere in azione quei
programmi sui tre compilatori che uso per studiare il
C++ senza andare a beccare delle rogne (da errori di
compilazione "normali" a "internal error" (!) ).
Usare roba simile in codice di produzione, a oggi,
secondo me sarebbe una scelta poco giustificabile.
Andre
