Newsgroup: it.comp.lang.c
Titolo: caratteri da minuscolo a maiuscolo in stringa

Come fare per portare i caratteri di una stringa da minuscolo a maiuscolo?
In rete trovo la soluzione, ma mi usa puntatori e funzioni di libreria che
per adesso il mio libro non ha toccato (sono a un pò meno della metà).
Eppure al capitolo che sto studiando, mi chiede questo tipo di esercizio.
Il programma mi si schianta poi...
Qualcuno può illuminarmi? Sono convinto che si può fare in termini molto più
semplici, ma io non riesco a trovare strade diverse ne l'errore ( comparison
between pointer and integer, ecc...).
Grazie
// per trasformare i caratteri da minuscoli a maiscoli...
#include <stdio.h>
char stringa2[]="trentatretrentini";
int x;
main()
{
for (x=0; stringa2[x]!="/0"; x++)
{
switch(stringa2[x])     {
        case "a":stringa2[x]="A";
        break;
        case "b": stringa2[x]="B";
        break;
        case "c":stringa2[x]="C";
        break;
        case "d": stringa2[x]="C";
        break;
        case "e":stringa2[x]="E";
        break;
        case "f":stringa2[x]="F";
        break;
        case "g": stringa2[x]="G";
        break;
        case "h":stringa2[x]="H";
        break;
        case "i":stringa2[x]="I";
        break;
        case "e":stringa2[x]="E";
        break;
        case "t":stringa2[x]="T";
        break;
        case "r":stringa2[x]="R";
        break;
        // ecc... facendo il caso per tutte le lettere dell'alfabeto
        }
}
printf ("%s",stringa2);
}

fromlucca wrote:
Noooo---
hai sbagliato tutti i caratteri.
I doppi apici servono per le stringhe "AAAA" i
singoli apici identificano i caratteri 'a', 'b' etc.
Bisogna che queste cose di base le sai bene altrimenti
non hai nessuna speranza...
la cosa che fai dopo con lo switch e' abbastanza
demenziale (senza offesa, deh)
fai una cosa tipo questa, piuttosto....
char B[100];
int i;
strcpy(B,"il mio nome e' Pinco Panco");
for (i=0; B[i]; i++)
   if (B[i]<='z' && B[i]>='a')
       B[i]=B[i]-'a'+'A';
il ciclo cicla fino a che trova il caratter nullo
poi l'IF controlla se il carattere
e' minuscolo (perche' se e' un carattere maiuscolo
o se e' un simbolo non alfabetico non deve fare nulla)
poi con l'operazione B[i]-'a'+'A' lo converto,
infatti, siccome B[i] e' minuscola allora
B[i]-'a' mi da lo spostamento del carattere rispetto alla
lettera 'a', ovvero se B[i] e' 'a' allora mi da' 0,
se e' 'd' mi da 3 etc.etc
Poi aggiungo il codice della 'A' maiuscola per ottenere
rispettivamente 'A', 'D' etcetc.
ciao,
g.

 g. 

}
aggiungi un "return 0;" alla fine
Ciauu
Mtc

 Non capisco. Perchè?
la cosa e' di una banalita' sconcertante.
Semplificando (a costo di attirarmi gli strali dei super
precisi, ma sto bevendo il brancamenta e tra poco mi
trasformero' nel Nano Bagonghi che e' molto sgarbato, mi
dicono...) la facenna e' questa:
i char (o gli unsigned char) che tu usi per memorizzare
caratteri e poi stringhe altro non sono che dei
numeri interi "piccoli", che vengono memorizzati ciascuno
in un byte (un byte e' solitamente composto da 8 bit e
puo' pertanto assumere 256 diversi valori, quindi
da 0 a 255 se unsigned o da -128 a 127 se signed).
Quindi quando tu scrivi
char xx = 'h';
nel byte che corrisponde alla variabile xx ci va a finire
non la lettera h (perche' il computer se ne infischia
della nostra letteratura) ma un numerino che poi
verra' interpretato (se necessario) come lettera h.
Per una convenzione (non necessariamente universale, ma
per ora accontentiamoci) i codici che
corrispondono alle lettere sono contigui e crescenti
rispetto all'ordine alfabetico.
Per esempio nel mio computer (e penso anche nel tuo...)
vale
A = 65
B = 66
C = 67
......
Z = 90
e poi le minuscole
a = 97
b = 98
c = 99
d = 100
.....
z = 122
Quindi se abbiamo B = "ciao", allora B[0] e' uguale
al carattere 'c' ovvero al numero 99.
Se da B[0] sottraggo la lettera 'a', ovvero il numero
97, ottengo 2 (e di fatto numerando le lettere da 0 in poi
la lettera c appare in posizione 2). A questo punto sommando
il risultato (2 = B[0]-'a') al valore di 'A' cioe' 65
ottengo 67 che vale appunto 'C'. Questo perche' anche nella
lista delle maiuscole la lettera C appare in posizione 2
se partiamo da 0.
Piu' chiaro di cosi' non riesco a spiegarlo.
ciao,
e.

       B[i]=B[i]-'a'+'A';
Non e` garantito che questo funzioni. Solo la codifica dei  caratteri
numerici deve essere contigua a norma di standard.
toupper/tolower sono funzioni estremamente semplici, fatte apposta per
questo.
Luca
-- 
Home: 
http://kronoz.cjb.net
"I've seen things you people wouldn't believe...
 Attack Ships on fire off the shores of Orion.
 I've watched C-beams glitter in the dark off of Tanhauser Gate.
 All those moments will be lost in time...like tears, in rain.
 Time to die." -- Roy Batty (played by Rutger Hauer)

 numerici deve essere contigua a norma di standard.
Infatti Caro Estintore aveva premesso che la
convenzione poteva non essere universale. Penso che fosse piu'
per far capire la relazione tra interi e caratteri.
Comunque sono curioso, mi fai per favore un esempio di sistema
in cui non funziona?
ciao,
g.

Giovanni Resta ha scritto:

Te lo faccio io: 
http://www.likit.lt/all/stand/st_img/ebcdic-k.gif
Trattasi di una variante nazionale dell'EBCDIC che si usa ancor oggi su
alcune architettiure IBM. Come vedi:
1) Le lettere minuscole dell'alfabeto inglese vengono PRIMA delle maiuscole,
quindi l'espressione c=c-'a'+'A' non funziona (bisognerebbe invertire il +
con il -).
2) Fra la "i" e la "j" e fra la "r" e la "s" ci sono dei caratteri extra,
quindi il test if (B[i]<='z' && B[i]>='a') non funzionerebbe.
Ma anche bestiacce come l'EBCIDIC non esistessero, resta il fatto che il
codice qui sopra (e qualsiasi altro codice simile, che vada a pasticciare
direttamente con i codici carattere) supporta solo e unicamente le 26
lettere dell'alfabeto inglese!!! Se uno cercasse di usare quel codice sulla
parola italiana "città", otterrebbe "CITTà" anziché "CITTÀ".
Se questo metodo non supporta manco l'italiano, si può ben immagina lo
sconquasso che potrebbe fare con il lituano o (e qui, "fromlucca", la cosa
ti riguarda direttamente) con le lingue dell'Africa sub-sahariana, che usano
spesso ortografie complicatissime con decine e decine di lettere extra.
Quindi, COME MINIMO, per fare queste cose è opportuno utilizzare le funzioni
standard tolower() e toupper(), le quali sono implementate tenendo conto del
character set e addirittura della LINGUA DELL'UTENTE dell'ambiente nel quale
il programma girerà.
In ogni caso, anche tolower() e toupper() non sono del tutto sufficienti.
Una conversione da Xuscole a Yuscole fatta carattere per carattere non
sempre funziona. Ad esempio, la lettera minuscola tedesca "ß" (un singola
lettera, detta "sharfes Es") in maiuscolo diventa "SS" (due lettere!). Per
risolvere anche simili problemi, bisogna per forza fare la conversione
dell'intera stringa, utilizzando metodi un po' più sofisticati, come per
esempio quelli forniti dalla libreria ICU (
http://oss.software.ibm.com/icu
).
Ma nemmeno una libreria di fantascienza come l'ICU può risolvere casi
particolari come per esempio una certa convenzione degli americani per cui
cognomi come "McIntosh" o "DiCaprio", che in maiuscolo diventano "McINTOSH"
e "DiCAPRIO, con la seconda lettera che rimane comunque minuscola per
indicare che si tratta due parole fuse insieme.
Insomma, in generale, la conversione "di cassa", se vista in prospettiva
internazionale, è una cosa parecchio complicata. Io SCONSIGLIEREI caldamente
di farla all'interno dei programmi se non strettamente indispensabile.
Per bene che vada, una conversione del genere è comunque una CORRUZUINE DEI
DATI: se qualcuno si è preso la briga di battere un certo testo con una
certa combinazione di maiuscole o minuscole, una ragione l'avrà pur avuta,
no? Facendo una case conversion tu questa distinzione la butti via. E questa
perdita di informazioe non è che sia possibile recuperarla in seguito: se
"McIntosh-straße" me lo converti in "MCINTOSH-STRASSE", poi vogli vederti a
ricostruire la stringa originale!
Le funzioni tolower() e toupper() io le userei solo per lettere singole e
non per parole complete. Ad esempio, può andar bene fare una cosa del
genere:
    printf("Sei sicuro di voler cancellare? [SN]\n", nomeFile)
    risposta = getchar();
    if (toupper(risposta) == 'S')
       delete(nomeFile);
--
Cingar
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 ha scritto nel messaggio 
news:zFVfd.94408$b5.45...@news3.tin.it...
