Newsgroup: it.comp.lang.c++
Titolo: stringstreams e DJGPP

Cari amici, grazie a Francesco Cipriani sono riuscito a far funzionare
le stringstreams anche con il mio DJGPP (almeno dalle poche prove che ho
fatto). Mi dà però un warning ad una riga (esattamente la 250 di
sstream.cc) dove confronta la differenza tra due puntatori con un long
unsigned int, dicendo che sto confrontando un signed con un unsigned.
Ecco la riga:
if (_CS_pos < 0 || (_CS_p - _CS_m_beg) < _CS_pos)
dove _CS_pos è un long unsigned int e _CS_p e _CS_m_beg due puntatori.
Secondo voi come posso fare per evitare il warning? Tra l'altro non ho
neanche capito che senso abbia controllare se un unsigned è minore di
zero.
Ciao a tutti.
EMG

zero.
In C++ la valutazione di una espressione booleana si ferma non appena e`
evidente il risultato. Quindi se "_CS_pos<0" la seconda parte di quella
espressione non viene valutata.
Per evitare il warning dovresti disabilitarlo (meglio solo
momentaneamente) tramite una #pragma sempre ammesso che il
tuo compilatore te lo permetta.
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

 tuo compilatore te lo permetta.
Forse mi sono dimenticato di dire che il warning si riferisce alla
seconda parte. Più precisamente
if (_CS_pos < 0 )
questa da sola non dà warning. Quest'altra si
if ((_CS_p - _CS_m_beg) < _CS_pos)
La differenza tra due puntatori sembrerebbe quindi un signed che
confrontato con l'unsigned genera il warning. Come posso eliminarlo?
Dove devo mettere il cast senza correre il rischio di alterare la
semantica dell'espressione? Inoltre resto con il mio dubbio: ha qualche
senso confrontare un unsigned con il valore zero (come succede nella
prima parte)?
EMG

>dove _CS_pos č un long unsigned int e _CS_p e _CS_m_beg due puntatori.
Scusami... Mea culpa!!!!
Ero convinto che _CS_pos fosse signed!!!!!!!!!!!


confrontato con l'unsigned genera il warning. Come posso eliminarlo?
prova a scrivere ((_CS_p - _CS_m_beg) - _CS_pos) < 0


 prova a scrivere ((_CS_p - _CS_m_beg) - _CS_pos) < 0
Giusto! Così sembra tutto OK. Grazie.
EMG

evidente il risultato.
Se non mi sbaglio, questa e' una regola valida solo per i built-in,
non per i tipi definiti dall'utente
--
 (o-  | c:\> win2000patch001.exe
 //\  | This Microsoft(c) patch fix all bugs present. All rigth reserved.
 V_/_ | Insert Linux boot disk to continue ... loading kernel ...
http://pinguin.linuxbox.com
 r.salmaso(at)
flashnet.it

 tuo compilatore te lo permetta.
Disabilitare i warning e` una pessima prassi; personalmente
preferirei introdurre una funzione ausiliaria come ad esempio:
template<class T>
inline bool isPos(T x) {
    static const maxPos = static_cast<T>(-1L)>>1;
    return x <= maxPos;
}
e cambiare la parte
    _CS_pos<0
in
    isPos(_CS_pos)
Quanto alla seconda meta` dell'&,
    (ptr1 - ptr2) < uns3
che causa un errato paragone fra signed
(la ptrdiff_t della differenza fra puntatori) e
unsigned (uns3), puo` essere aritmeticamente
trasformata in
    ptr1 < (ptr2+uns3)
che e` un confronto fra puntatori, privo
di problemi di segno/nonsegno.
Alex

 confrontato con l'unsigned genera il warning. Come posso eliminarlo?
if(_CS_p < _CS_m_beg+_CS_pos)
come da mio post precedente.
Alex

Non esattamente: e' valida per gli *operatori* built-in, ma non per gli
*operatori* ridefiniti dall'utente. Per questo motivo Scott Meyers in
Effective C++ (o More Effective C++, non ricordo) sconsiglia vivamente
di ridefinire gli operatori || e && .
Ciao,
Nicola

non per i tipi definiti dall'utente
Si... non l'avevo sottolineato ma e` proprio cosi`.
Ovviamente salvo ridefinizione...


Giusto! Così sembra tutto OK. Grazie.
Figurati... oggi a te domani a me!
