[c++] valore dei caratteri

[mamo139]

printf("\n\n%d",'€'); mi dà come numero -128
printf("\n\n%d",'è'); mi dà come numero -24

ma perche??? :confused:
insomma il valore di un carattere non dovrebbe andare da 0 a 255??? :mc:

[mamo139]

con printf("\n\n%d",'f'); mi dà il giusto valore 102
e con con printf("\n\n%c",102); ridà alla perfezione la f

[andbin]

printf("\n\n%d",'€'); mi dà come numero -128
printf("\n\n%d",'è'); mi dà come numero -24

ma perche??? :confused:
insomma il valore di un carattere non dovrebbe andare da 0 a 255??? :mc:Partiamo innanzitutto dalla questione del segno: il char tipicamente è un tipo di dato "segnato". Questa è l'impostazione di default nella maggior parte dei compilatori. Nota che lo standard ANSI C/C++, non precisa se il char debba essere signed o unsigned. La scelta viene lasciata alla implementazione specifica del compilatore.
In genere il compilatore consente anche di specificare una opzione per impostare la gestione del char come unsigned.
Nella maggior parte dei casi, il fatto di avere un char signed o unsigned è ininfluente per il programmatore.

Come seconda cosa, specificare un carattere non ASCII direttamente nel sorgente non è una buona cosa. Infatti bisogna vedere con quale set di caratteri è stato scritto il sorgente e quale è il set di caratteri adottato dal dispositivo che dovrà stampare la stringa.

[-fidel-]

printf("\n\n%d",'€'); mi dà come numero -128
printf("\n\n%d",'è'); mi dà come numero -24

ma perche??? :confused:
insomma il valore di un carattere non dovrebbe andare da 0 a 255??? :mc:

Dipende dall'implementazione che è stata fatta nelle standard c run-time libraries di Windows (perchè stai programmando su Windows mi pare di capire). Se vuoi stampare caratteri ascii estesi (dal 128 in poi) o caratter unicode o altro, usa:

"wprintf" per unicode
"_tprintf" se usi tchar.h per avere facilmente compatibilita per sistemi Unicode o non Unicode

[mamo139]

ok... ma sei leggessi questo € da un file in modalità binaria
f = fopen("test.txt","rb");
char c = fgetc(f);
non mi dovrebbe dare un valore "normale"??

se io provo a trasformare lo stesso carattere in esadecimale col codice che mi ha dato come esempio andbin, ovvero
printf("%02X", (unsigned char)c);
mi da come risultato 80... ovvero 128 in decimale...
ma provando a ridargli questo valore così
printf("%c",128);
mi salta fuori un altro carattere... questo: ç .... perche??
:muro: :muro: :muro:


[EDIT]
usando questo programma sempre con dentro il file solo 80 (ovvero il valore esadecimale dell'€)


#include <stdio.h>

main(){
FILE *fp, *fw;


if((fp = fopen("test2.txt","wb")) == NULL) return 0;
if((fw = fopen("out.txt","rb")) == NULL) return 0;


int v;
unsigned char c;
while(fscanf(fw, "%02X", &v) == 1)
{
c = (unsigned char)v;
qui ho provato a vedere che valore ha c... e vale 128...
quindi perche il printf qui sotto stampa € mentre il mio dell'esempio sopra no???
fprintf(fp, "%c", (unsigned char)c);
}


fclose(fw);
fclose(fp);

getchar();
}

[-fidel-]

Stai facendo un po' di confusione.
E' un problema di interpretazione del carattere. Se tu lo leggi da un file con unsigned char, e lo scrivi con fprintf su un altro file, e il file lo apri con Blocco note, quest'ultimo, riconoscendo l'ascii esteso, quindi la codifica che vuoi usare, interpreta bene il carattere. Quando tu invece specifichi alla printf un carattere tra apici (come nella tua printf("\n\n%d",'è');) la printf NON riesce a codificare quel carattere (il carattere tra apici non è presente nella sua tabella di conversione caratteri, perchè la printf interpreta il carattere tra apici per trasformarlo in un valore numerico). Tutto qui. Prova a fare printf("\n\n%c", 130); e vedi cosa succede. Poi prova con la wprintf.
Inoltre, prova ad usare un puntatore a char (una stringa insomma), alloca due byte con la malloc, e fai una strcpy del tipo:


char *carattere;
carattere = (char*)malloc(2*sizeof(char));
strcpy(carattere,"é"); /* O strncpy(carattere, "é", 2); è più sicuro */
printf("%s\n", carattere);

e vedi cosa succede. Sperimenta :)
Nota che alloco 2 bytes: questo semplicemente per comprendere il terminatore di stringa inserito dalla strncpy (nel nostro caso in presnza di una stringa costante). Naturalmente se non ti piace la malloc puoi allocare staticamente...

Ah, ovviamente con unsigned char rappresenti al massimo i caratteri ASCII estesi, NON supporti la codifica Unicode (ma questo è un'altro discorso).

EDIT: dimenticavo, se hai la codifica Unicode sul tuo Sistema Operativo, allora tutti i caratteri saranno rappresentati su 16 bit, (a meno che non usi utf8 come su linux, che se vai oltre il carattere 127 passi a 16 bit) quindi dovrai prevedere 2 byte per carattere. Il problema delle codifiche (ed adattare il codice a queste codifiche), non sempre è un problema banale...

EDIT 2: Nell'esempio proposto con le stinghe, prova a fare poi "printf("%d\n", carattere[0]); e vedi cosa accade.

EDIT 3: su linux ad esempio (la mia distro usa UTF-8), se faccio la strncpy su un carattere tra 0 e 127, ho bisogno di 2 byte (uno per il carattere, l'altro per il terminatore di stringa utile per stampare bene la stringa con printf), mentre se metto un carattere da 128 in su, avrò bisogno di 3 bytes (2 per il carattere, 1 per il terminatore di stringa).

[andbin]

ok... ma sei leggessi questo € da un file in modalità binaria
f = fopen("test.txt","rb");
char c = fgetc(f);
non mi dovrebbe dare un valore "normale"??
[...]Come ha già detto -fidel-, stai facendo un po' di confusione.

Innanzitutto devi capire tutta la questione relativa ai set di caratteri! Apri il blocco note di Windows (notepad) e scrivi le lettere accentate:
àèìòù

Salva il file, poi apri un prompt dei comandi e quindi apri il file appena salvato con il classico 'edit'. Quello che vedi sono dei simboli strani:
http://img244.imageshack.us/img244/3377/editfl7.gif

Perché??? Semplice: perché la console di Windows e i programmi con interfaccia grafica usano set di caratteri diversi!! La console tipicamente usa il set di caratteri CP-850 (almeno in Italia e in altri paesi europei) mentre Windows in generale usa il set CP-1252 (detto anche WIN-1252).

Per il simbolo dell'Euro, c'è da fare attenzione: i set di caratteri per la console (es. CP-850, CP-437, ecc...) non contemplano il carattere dell'Euro (almeno che io sappia ... non li conosco tutti).
Su Windows con il set di caratteri WIN-1252, l'Euro ha il codice 0x80, però dipende anche dal font di carattere usato. Il font "Fixedsys" non ha il simbolo dell'Euro, mentre l'Arial o Times New Roman, molto probabilmente ce l'hanno.
Nel set di caratteri ISO-8859-15 ad esempio, l'Euro ha codice 0xA4. Mentre in Unicode ha codice U+20AC.

Insomma ... questo è il "mondo" del set dei caratteri. ;)

[mamo139]

beh con una prova ho scoperto che se mi esce il numero negativo posso rimediare con un bel "256 meno il numero"

il programma che cmq stavo provando a fare serve a convertire un file nel suo equivalente binario...
grazie all'aggiunta del pezzo in rosso ora sembra funzionare...


#include <stdio.h>

main(){
FILE *fp, *fw;
char c;

if((fp = fopen("test.txt","rb")) == NULL) return 0;
if((fw = fopen("out.txt","wb")) == NULL) return 0;


while((c = fgetc(fp))!=EOF){
char str[7];
int x, n = c , bit, i, j;

for(i=0;i<=7;i++)
{
str[i]=0;
}

if (n < 0) n = 256 + n;

for (x = 0;x<=7; x++)
{
bit = n%2; //il resto del numero diviso 2
str[7-x] = bit;
n=n/2;

}
for(j=0;j<=7;j++)
{

if (str[j]==0) str[j] = 48;
else if (str[j]==1) str[j] = 49;
else str[j] = 'E';

//printf("%c",str[j]);
fprintf(fw,"%c",str[j]);
}

}

fclose(fw);
fclose(fp);


getchar();
}

[andbin]

il programma che cmq stavo provando a fare serve a convertire un file nel suo equivalente binario...Ecco:
#include <stdio.h>

int main (int argc, char *argv[])
{
FILE *fin, *fout;
int c, i, m;
char binary[9];

if (argc == 3)
{
if ((fin = fopen (argv[1], "r")) != NULL)
{
if ((fout = fopen (argv[2], "w")) != NULL)
{
while ((c = fgetc (fin)) != EOF)
{
for (i = 0, m = 128; i < 8; i++, m>>=1)
binary[i] = c & m ? '1' : '0';

binary[i] = '\0';

fprintf (fout, "%s", binary);
}

fclose (fout);
}

fclose (fin);
}
}

return 0;
}
Non è più semplice?