Newsgroup: it.comp.lang.c++
Titolo: std::string

la classe std::string prevede un metodo per convertire tutti i
caratteri in maiuscole o minuscole?
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

 wrote in message
news:skrmbsc7cje28auls...@4ax.com...


 > caratteri in maiuscole o minuscole?
_strupr e _strlwr non sono standard; poi, sei sicuro di quanto
affermi?  Si applicano a strings C++ o a C-strings?
Io userei:
string s("La vispa Teresa");
transform(s.begin(), s.end(), s.begin(), tolower);
transform(s.begin(), s.end(), s.begin(), toupper);
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

Ciao, Paolo.
Cito da un messaggio postato da Thomas Maeder su
borland.public.cppbuilder.language:
In general, since upper and lower case are language dependent, it's a
good
idea to use the localization machinery.
typedef std::ctype<char> CType;
CType const& ct = std::use_facet<CType>(std::locale());
ct has member functions toupper() and tolower() that you can use.
Credo che la "perfezione" sia combinare questo con quanto suggerito da
Maurizio.
Ciao,
Nicola
P.S. Posto che il tuo compilatore lo supporti...

 idea to use the localization machinery.
Hmmm...  non stiamo parlando di wstrings, qui?  "std::string" supporta
il charset ASCII normale, e "lowercase" e "uppercase" sono perfettamente
definite dal linguaggio (C, in questo caso).  CString, poi, non so
nemmeno cosa sia...


 caratteri in maiuscole o minuscole?
Ahime` no, poiche` std::string non incorpora un locale
(a differenza di std::iostream, che invece lo incorpora), e
la trasformazione minuscole/maiuscole e` strettamente
dipendente dal locale.
Devi dunque usare ctype<char>::tolower(s.begin(),s.end())
(o simili, a seconda del locale che ti interessa, ovviamente!)
invece di avere una comoda sintassi tipo s.lowerall().  E`
fortunatamente solo e rigorosamente un problema di
sintassi, e presenta molti casi analoghi in C++ standard:
dove uno (ragionando O-O) si aspetterebbe...:
    oggetto.metodo(argomento)
per le classi della libreria standard si trova invece spesso
a dire qualcosa come...:
    algoritmo(oggetto.begin(), oggetto.end(), argomento)
perche` la libreria standard ragiona piu` per genericita`
che non secondo i canoni O-O.  In effetti, la notazione
con begin ed end e` piu` generale, flessibile, ecc, pero`
a volte e` in effetti meno comoda e intuitiva (ma penso
che ci abitueremo abbastanza presto... *spero*!-).
Alex

 nemmeno cosa sia...
Errore...: std::string supporta qualsiasi codifica di carattere
a singolo byte -- non solo ASCII, che e` un codice a 7 bit,
ma anche le sue tante estensioni a 8-bit, come ISO 8859-1,
ISO 8859-2, eccetera.  Ma la corrispondenza minuscolo ->
maiuscolo e` DIVERSA per 8859-1, 8859-2, eccetera, quindi
e` impossibile per std::string (senza conoscenza di locale)
gestire queste corrispondenze.
(std::string e` anche in grado di supportare MBCS, che
sono cose diverse dai wchar_t supportati da wstring --
ad esempio, codifica SJIS piuttosto che Unicode per il
Giapponese -- ma queste specifiche problematiche, lo
auguro di tutto cuore a ogni lettore di questo gruppo, non
toccheranno probabilmente mai la vosta vita lavorativa, e
ve lo dice uno che di sangue ce ne ha sparso su tanto:-).
Alex

 P.S. Posto che il tuo compilatore lo supporti...
Il DJGPP purtroppo no... :-(
EMG

 Devi dunque usare ctype<char>::tolower(s.begin(),s.end())
Uffa! Il DJGPP non supporta neanche questo! Oppure bisogna includere un
header particolare?
EMG

P.S. Posto che il tuo compilatore lo supporti...
Tra le altre cose...
Sto cercando di scrivere la mia tesi in C++ standard
lavorando con compilatori che chi piu` chi meno, standard
non sono. Fortunatamente per quanto riguarda i contenitori
pare non ci siano problemi, l'unico guaio e` che in certi file
di terze parti sono definite macro che collidono con altre
di altri sorgenti...
Stanotte ho persino scoperto che due header non correlati tra
loro, hanno lo stesso nome.... puoi immaginare i problemi.


che ci abitueremo abbastanza presto... *spero*!-).
In verita` e` una cosa che apprezzo... In generale non amo la
GP anche se riconosco che in C++ ha un ruolo molto
importante. Comunque apprezzo molto gli iteratori ed il modo
in cui sono utilizzati.


Beh, dovrebbe essere sempre disponibile il buon vecchio <ctype.h>, che
magari e' pure standardizzato come <cctype> (non sono sicuro). Li trovi
le "toupper" e "tolower" originali. Questo file esiste da decenni e
penso che qualunque compilatore se lo porti appresso. Lavora ovviamente
su ASCII, pero' magari ti basta.
Ciao,
Nicola

 wrote in message
news:38BCD081...@divalsim.it...

#include <ctype.h>
e` perfettamente accettabile in un programma standard C++,
e gestisce i locale (a norma di standard ISO C) sia pure in modo
piu` complesso (non e` quindi vero che sia limitato ad ASCII).
Purtroppo, toupper NON funziona su di un _range_ di
caratteri -- devi fare un ciclo esplicito carattere per
carattere, potenzialmente con sostanziale perdita di
efficienza.  Ma se devi lavorare in C (o con compilatori
C++ antichi, non standard), "o bere o affogare".
Alex

Infatti ho utilizzato proprio quello!
