Newsgroup: it.comp.lang.c++
Titolo: Funzioni Val() e Str() di visualbasic in cpp

Esistono?
In che libreria sono?
In che namespace sono definite le declare?
Bye,
--
Carmine ( 
pikachu...@gmail.com
 (Togli la scritta NOSPAM) )
Webmaster di The Total Site (
http://www.tekkentag.altervista.org/
 )
Webmaster di SceptilePage (
http://www.sceptilepage.altervista.org/
 )
Account Messenger: 
thetot...@msn.com
MyBLOG (NEW!!) 
http://spaces.msn.com/members/itanet/

 Esistono?
No.
-- 
Horst

> No.
E come posso fare per convertire una stringa in valore e un valore in
stringa ?
Che funzioni devo usare?


 Che funzioni devo usare?
Dalla libreria standard, la parte ereditata dal C:
#include <cstdlib>
std::atoi()
std::sscanf()
std::sprintf()
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg
The EMG Music page:         
http://www.emagsoftware.it/emgmusic

 std::sprintf()
Embhè, stampa sulla console una stringa... e a me a che serve?


 Embhè, stampa sulla console una stringa... e a me a che serve?
No, stampa su una stringa non sulla console. E quindi converte qualsiasi
valore numerico in una stringa.


 valore numerico in una stringa.
Quindi...
---
#include <string>
#include <cstdlib>
//un intero
int uno = 1;
std::string uno1 = std::sprintf(uno);
---
^ giusto?


 In che namespace sono definite le declare?
Esistono come ti hanno detto, le librerie ereditate dal C.
atoi, atof , sscanf e sprintf.
Tuttavia a titolo informativo puoi anche usare gli operatori << e >> 
degli stream.
Eccoti un semplicissimo esempio.
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
int main()
{
         // crea uno stream di stringa di input
         istringstream is("1980.0 72.69");
         // crea uno stream di stringa in output
         ostringstream os;
         // legge da is un numero
         float num;
         is >> num;
         // legge da is una stringa
         string s;
         is >> s;
         // scrive su os un testo qualsiasi (anche con numeri)
         os << "num=" << num << " s=" << s << endl;
         // legge la stringa scritta su os
         s=os.str();
         // e la scrive sul video
         cout << s;
         return 0;
}

 ^ giusto?
No, così (non testato):
#include <string>
#include <cstdlib>
//un intero
int uno = 1;
char buffer[100];
std::sprintf(buffer, "%d", uno);
std::string uno1 = buffer;



Mmm... si, prima io facevo così:
#include <string>
#include <iostream>
/* Usa lo stream << per concatenare le stringhe come fossero
    oggetti a cui inviare valori */
std::string uno = "1";
int uno1 = 1;
std::string intpiustring = uno << uno1;  // mi dà 11


 std::string uno1 = buffer;
Ma il buffer deve essere un array di caratteri? non ho capito bene...


 Ma il buffer deve essere un array di caratteri? non ho capito bene...
Sì, in quanto le funzioni ereditate dal C vogliono ovviamente gli array di
caratteri in quanto non possono certo conoscere i tipi del C++.
Se vuoi utilizzare le std::string allora prova con questo:
#include <iostream>
#include <string>
#include <sstream>
void IntToString( std::string &s, int n )
{
    std::ostringstream oss;
    oss << n;
//  s.swap( oss.str() );
    oss.str().swap( s );
}
std::string IntToString2( int n )
{
    std::ostringstream oss;
    oss << n;
    return oss.str();
}
int main()
{
    int n = 12345;
    std::string s;
    IntToString( s, n );
    std::cout << s << std::endl;
    std::cout << IntToString2( n ) << std::endl;
}
e questo:
#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;


 parlassi di c-stringhe (array di caratteri, appunto).
Ha appunto...

Mmm... okay, le provo.


 std::sprintf()
Non. Sono péricolosi et molto difficile a utilisare. (In fatti,
sprintf era considerato cosi pericoloso che non si usa néanche
in C.) Piùtosto les operatori in <sstream>. Per essempio, per
stampare un valore :
    std::cout << valore ;
std::cout è uno stream d'uscita. Mà ne esistono altre : per
scrivere un valore in un file :
    std::ofstream dest( "valore.txt" ) ;
    dest << valore ;
o per obtenerlo in una string:
    std::ostringstream dest ;
    dest << valore ;
    dest.str() ;
L'interessante qui è che infatti, il compilatore fà lo scelto di
quella funzionne (quell'operator<<) utilisare. E dunqu'è
impossibile de sbagliarsi.
--
James Kanze                                           GABI Software
Conseils en informatique orientée objet/
                   Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, 
+33 (0)1 30 23 00 34

 Piùtosto les operatori in <sstream>.
Ho fornito anch'io esempi con la sstream (forse ti sono sfuggiti).


 in C.) 
sono rischiosi se non si ha famigliarità coi puntatori e con le 
dimensioni dei tipi di dati .... Ma cosa non è pericoloso in C 
senza queste familiarità ? Oddio, bisogna studiarsi anche molto 
bene i corrispondenti meta-comandi di formattazione. In effetti 
definirei le funzioni con di libreria con ELLIPSIS complesse e 
talvolta poco efficienti, ma pericolose per funzioni di libreria 
mi pare un po' troppo severo. In sé non lo sono, anche se è 
facile mis-usarle.
Per il resto il tuo post è molto preciso e pertinente e si vede 
che usi molto il linguaggio
Ciao
Soviet-Mario


 Questa invece è proprio una cosa non vera.
E tanto vera ch'il comitato di normalizatione di C ha sentito il
bisogno di aggiungere una nuova funzione per sostituirla. In
fatto, è un po come gets() -- esista ancora, ma è impossibile a
utilisare in una codice corretto.


 pare un po' troppo severo.
Il pericolo è dalla parte dell'utilisatore. Tu scrivi "%d",
perche hai un int. Più tarde, un altro lo cambio in long, perche
int non basta. E quanti volte ho visto delle cose come:
    char buffer[ 5 ] ;
    sprintf( "%d", unoInt ) ;
Tavolte, atoi puo servire, ma ancore li, in generale, strtol è
preferibile.


 bisogno di aggiungere una nuova funzione per sostituirla.
E con quale funzione l'avrebbe sostituita? E da quale revisione del C? Resta
il fatto che la sprintf() era usatissima (almeno in mancanza di meglio).
Pensa che (anche se non dimostra niente) anche Windows offre un'API simile
(wsprintf()).


 (wsprintf()).
snprintf.
In generale, non si usa mai, ma proprio mai, una funzionne che
scrive in un buffer senza sapere quanto è grosso il buffer.


 scrive in un buffer senza sapere quanto è grosso il buffer.
Intendiamoci, nella sostanza sono d'accordo con te. E' il modo troppo
categorico in cui lo dici che non condivido.



io sapevo che le stringhe in C è un  puntatore a char* che punta al primo 
carattere della stringa (infatti la funzione c_str() restituisce un const 
char* ).  Sapevo male? 

 char* ).  Sapevo male?
Giusto, in C (a parte il fatto che c_str() in C non esiste). In C++ invece le
stringhe sono un tipo a parte (std::string).
