Newsgroup: it.comp.lang.c++
Titolo: esiste una funzione per ASCII?

Sapete per favore dirmi se in C++ esiste una funzione per convertire i
caratteri nel corrispondente codice ASCII?
grazie

 ha scritto nel
messaggio news:3Q4W5.3369$bP.1...@twister2.tin.it...


 i = (char) c;
non c'è bisogno del cast esplicito, in quanto si applica la promozione tra
tipi interi.
Ciao Fbf.

 ha scritto nel messaggio
news:3A28F60A...@libero.it...


E' meglio metterlo il cast per rendere il codice più leggibile. 
Non vedo in che modo.
Questo e' uno dei classici casi, noto a tutti, in cui il cast e'
assolutamente inutile.
-- 
Andrea Laforgia (ICQ# 87230455) --------------------------
Non scrivetemi in privato, se non richiesto espressamente.
No replies in private e-mail, unless explicitly requested.
----------------------------------------------------------

caratteri nel corrispondente codice ASCII?
E' implicita.
char c = 3 ;
int  a = c ;
Il tipo char e' considerabile un tipo intero.


i = (char) c;
forse intendevi
  i = (int) c;
???
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 Il tipo char e' considerabile un tipo intero.
Un tipo char e' convertito automaticamente in tipo intero nelle
espressioni,
ma non e' considerabile un tipo intero in assoluto;un char e' un char, un
int e' un int.
--
Ivan Molella
__LINUX__ the choice of the __GNU__ generation
icq# 97960484

 int e' un int.
Forse voleva dire che char è un tipo numerico.
EMG

 ha scritto nel messaggio
news:3a29a13e...@news.interbusiness.it...



Oppure ancora meglio:
i=int(c);
Più leggibile, ma pur sempre inutile...
Luc.

int e' un int.
Un "char" in C e' considerabile un tipo intero, a differenza di molti
altri linguaggi.
L'ANSI C Rationale afferma testualmente :
"The type signed char was introduced to make available a one-byte
signed integer type on those systems which implement plain char as
unsigned.  For reasons of symmetry, the keyword signed is allowed as
part of the type name of other integral types." 
--
Andrea Laforgia (ICQ 87230455)
------------------------------ 
#exclude <windows.h>

Alla fin fine stiamo facendo una discussione inutile. Ognuno fa come gli
pare tanto le cose funzionano uguale, non sei d'accordo?
"Luc" <TOGL...@katamail.com-TOGLI> ha scritto nel messaggio
news:qbjm2tobn9ti622em...@4ax.com...


pare tanto le cose funzionano uguale, non sei d'accordo?
Capita, a volte, ma tant'č....
Luc.

pare tanto le cose funzionano uguale, non sei d'accordo?
Il funzionamento non e' garanzia di correttezza.


 ha scritto nel messaggio
news:cf5n2tcc24regcqef...@4ax.com...


int e' un int.
Solitamente "tipo intero" e "tipo int" non sono sinonimi: i "tipi
interi" comprendono gli int, unsigned int, (unsigned) long int,
signed/unsigned char, eccetera.
Come i "tipi in virgola mobile" comprendono i float, i double
eccetera.
Anto

 #exclude <windows.h>
Effettivamente lo Stroustrup dice:
I tipi booleano,carattere, intero si dicono,nell'insieme,'tipi interi'.
Quello che intendevo io e' di non intendere letteralmente tipo intero in
senso stretto,ma in senso piu' lato onde evitare di poter pensare di
assumere: sizeof(int) = sizeof(char) con tutte le conseguenze che ne
derivano.


giusta.
"Non credo sia valida... tuttavia e' giusta".
Mah !
Io non credo sia valido affermare che una discussione e' inutile
perche' alla fine le cose funzionano "uguale".
I programmi possono anche funzionare (specie nel caso dei cast, vedi
il cast sul valore di ritorno di malloc) ma questo non assicura che
siano corretti.


derivano.
E che significa ?
Anche sizeof( long ) e' diverso da sizeof( int ) nonostante entrambi
SIANO tipi interi in senso "stretto".
A parte il fatto che evitare di poter pensare che sizeof( int ) =
sizeof( char ) e' errato, perche' ci potrebbero essere macchine con
interi da 1 byte e quindi equivalenti ai char.


 giusta.
Io invece concordo con Andrea. I cast sono abbastanza unanimamente
considerati operazioni da evitare il piu' possibile. Introdurne di
inutili per sottolineare conversioni garantite dal linguaggio, e per di
piu' per niente esoteriche, mi pare una pratica perniciosa.
Infatti puo' portare chi giustamente trova normale assegnare un char a
un int a perdere del tempo a domandarsi perche' diavolo c'e' il cast.
Meglio abituarsi a come funziona il linguaggio, che non sottolineare col
codice gli aspetti che a prima vista ci lasciano perplessi.
Ciao,
Nicola

Il problema e' che in italiano usiamo "intero" per tradurre sia "int"
che "integral".
Ciao,
Nicola

un int a perdere del tempo a domandarsi perche' diavolo c'e' il cast.
Esatto, e' proprio questo il punto, che contraddice la leggibilita'
del codice. Voglio dire : non si puo' dire che un codice sia
maggiormente leggibile usando il cast, se poi il programmatore poco
esperto perde un sacco di tempo a cercare di capire a cosa possa mai
servire quel cast (tanto piu' che, se poco esperto, gli viene da
pensare che se ce l'hanno messo, un motivo ci sara', con tutte le
riflessioni e perdite di tempo che ne conseguono).


 interi da 1 byte e quindi equivalenti ai char.
Non c'era un limite inferiore ai 16 bit per gli int?
EMG



Si; e' un byte (inteso come memory storage per 1 char) che potrebbe
avere 16 bits.
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it
Murphy's law: "Anything that can go wr
/bin/fortune: segmentation fault - core dumped

Non c'era un limite inferiore ai 16 bit per gli int?
Gia', ma un char puo' anche essere lungo 16 bit, perche' un byte puo'
anche essere lungo 16 bit e quindi avresti sizeof(char)=sizeof(int).





 interi da 1 byte e quindi equivalenti ai char.
Mi riferivo al 99.9% delle implementazioni.



Rileggendo il thread mi sono accorto di una mia imprecisone di fondo,l'aver
confuso la denominazione matematica di "intero",con il "tipo int.".
Del resto sono anche queste discussioni all'apparenza inutili che ci
permettono di fissare certi sottili concetti che certe volte sfuggono.... :)


Mi riferivo al 99.9% delle implementazioni.
Peccato che qui dentro non si discuta il 99.9% delle *implementazioni*
ma lo standard ufficiale.
