Typecasting esplicito - Boolean

[DragoRosso]

Ciao di nuovo.

Questa volta il riferimento è legato ad un comportamento di FPC (Lazarus) che ha generato nella comunità internazionale decine e decine di pagine in vari topic. Non riporto neanche i riferimenti perchè le discussioni sono a livello non degradato, molto più basso ....

In particolare la rappresentazione di un valore booleano in Lazarus non corrisponde a quanto specificato nella documentazione ufficiale e molti discutevano che, anche se viene bene definito che un booleano non può contenere valori diversi da 0 e 1 pena una condizione indefinita poi nel suo trattamento, il compilatore (ed il runtime pure) non fanno nulla per ovviare a ciò, anzi allegramente consentono di effettuare operazioni non consentite.

Lasciando perdere tutti i discorsi filosofici (alla stregua del sesso degli angeli), è necessario capire quale sia la buona condotta di un programmatore nel trattare un booleano, conoscendo i limiti del compilatore e del runtime, al fine di non incorrere in problemi che effettivamente possono pregiudicare l'intero applicativo e possono altresi portare a condizioni anche di esecuzione a rischio.

Riporto questo come riferimento, in quanto solo qui vengono definite alcune "regole" su false / true in FPC: https://wiki.freepascal.org/false_and_true

In un piccolo versetto a fine pagina si asserisce che qualsiasi valore in un "boolxxxx type" deve essere 0 o 1, altri valori sono indefiniti (tenete conto che appena qualche riga sopra è definito che un valore diverso da zero è inteso come TRUE !!!)

IN DELPHI (inteso come compilatore Delphi, non la modalità FPC) viene specificato che fare un casting con un booleano E' CONTROINDICATO (ciòè se lo fai sono ca..i tuoi).

Essenzialmente partiamo dall'errore di base:

Codice: [Seleziona]

var b: boolean;
var c: boolean;
//CASTING DI UN VALORE !!! DA NON FARE MAI CON I BOOLEANI.
//Questo casting porta ad avere una variabile booleana la cui valutazione è TRUE, ma con un enorme problema
//N.B. il valore 6 potrebbe provenire come risultato di una qualsiasi funzione (magari da una libreria esterna).
b := boolean(6);

//Per verificarlo facciamo questo
c := boolean(5);

  if b then
    writeln('b is true');

  if c then
    writeln('c is true');

  if b = c then
    writeln('b and c are the same')
  else
    writeln('b and c are NOT the same');

//Provate ad eseguire quanto sopra e scoprirete che nonostante le due variabili risultano a TRUE la loro comparazione non viene verificata !!!
//Questo è un problema enorme

Quindi essenzialmente dovremmo in qualche modo aggirare il problema e a meno di non effettuare un controllo preliminare per ogni assegnazione potenzialmente a rischio, è necessario che operiamo diversamente.

Qui ci aiutano le definizioni ByteBool, WordBool, etc ...

Con queste possiamo effettuare il casting senza "paura" di cadere in errore. Và usata ovviamente la funzione che meglio si adatta alla sorgente del valore: usere ByteBool(x) se il valore x ha capacità di un byte .....

Questo è lo stesso identico esempio ma corretto con il ByteBool ..

Codice: [Seleziona]

var b: boolean;
var c: boolean;
b := ByteBool(6);
c := ByteBool(5);

  if b then
    writeln('b is true');

  if c then
    writeln('c is true');

  if b = c then
    writeln('b and c are the same')
  else
    writeln('b and c are NOT the same');

//Ora il codice risponde correttamente.

Da notare che in Delphi il comportamento è simile, con l'eccezione che il valore (-1) o (1) si equagliano nel casting diretto di un boolean e quindi anche nella comparazione evitando così la stragrande maggioranza dei problemi.

In molte librerie, il TRUE viene rappresentato come -1 (ad esempio in certi DB) invece che come 1. Ciò in Delphi non rappresenta un problema anche se viene "castato" direttamente, in Lazarus invece viene gestito con due valori diversi generando l'anomalia.
EDIT: questo rappresenta più un colpo di fortuna e non deve essere una scelta ... se il compilatore cambia è possibile che cambi anche questo comportamento ...


Operando correttamente quindi possiamo evitare probabili e possibili anomalie, spesso future che si amplificano magari con un banale cambio di versione.

Bye bye