Über den Umgang mit Boolean

[negaH]

Zitat:

Was ist denn hier schneller / angebrachter / richtiger?

Keines von beiden ist richtiger noch schneller als das andere, aber lesbarer und kürzer und nicht so umständlich ist

Delphi-Quellcode:

BoolVar := Value <> 5;

sehe ich sowas

Delphi-Quellcode:

BoolVar := not (Value = 5);

in einem Source so weis ich sofort mit Sicherheit das der Programmierer der dies so schreibt eben nicht in der Lage ist Formeln umzustellen. Und das Ziel ist es eben auch ein Problem im Source so zu lösen das es fast schon genial einfach erscheint.

Gruß Hagen

[TiGü]

Wie sieht denn das eigentlich im Verhältnis zu C/C++ aus?
Oft sehe ich bei Kollegen die in diesen Sprachen programmieren Sachen wie ... == false/true!

[Sherlock]

Bei C/C++ ist eh Hopfen und Malz verloren.
*SCNR*

Spaß beiseite: Es kann bei den von Dir genannten Fällen durchaus sein, daß die zu vergleichende Variable gar keine Boolean ist, sondern zB ein Integer oder auch ganz was anderes, C erlaubt entsprechend phantasievolle Vergleiche, und gibt sogar manchmal die erwarteten Ergebnisse zurück. Da lob ich mir doch eine typensichere Sprache.

Sherlock

[Medium]

Geade bei C (ohne ++) gab es das Problem, dass es keine standardmäßigen Konstanten für true/false gab, und somit jeder in seinem Abschnitt seine eigenen derlariert hat. Dadurch konnte er dann recht sicher sein, dass Gleichheit besteht, komfortabel war/ist das insgesamt aber wohl eher nicht :)

Bei C(++) gilt: 0=false, egal was für einen Typ man vor sich hat. So wird ein "if Assigned(MyInstance) then..." dort oft auch zu einem "if (MyInstance) {...}".

[himitsu]

Joar, False ist eigenttlich immer 0 (wenn der Boolean als ordinaler Type angelegt ist), also "nichts".

Wobei aber das Delphi-True = 1
und das C-True = -1

Code:

Die standardisierten Konstanten:

True:
  Boolean         = $01
  ByteBool / bool = $FF
  WordBool        = $FFFF
  LongBool / BOOL = $FFFFFFFF

False:
  Boolean         = $00
  ByteBool / bool = $00
  WordBool        = $0000
  LongBool / BOOL = $00000000

In der Auswertung ist es aber immer:
False = 0
True <> 0
True = nicht False

Und schon fällt auf, warum

Delphi-Quellcode:

= True

nicht korrekt sein kann.

Delphi-Quellcode:

= False

würde zwar problemlos gehn, aber wenn man

Delphi-Quellcode:

= True

nicht nehmen darf kann, warum soll man sich dann mit

Delphi-Quellcode:

= False

auch noch rumschlagen. (schön einheitlich halt)

[JamesTKirk]

Zitat:

Zitat von himitsu (Beitrag 1149609)

Joar, False ist eigenttlich immer 0 (wenn der Boolean als ordinaler Type angelegt ist), also "nichts".

Wobei aber das Delphi-True = 1
und das C-True = -1

Code:

Die standardisierten Konstanten:

True:
  Boolean         = $01
  ByteBool / bool = $FF
  WordBool        = $FFFF
  LongBool / BOOL = $FFFFFFFF

False:
  Boolean         = $00
  ByteBool / bool = $00
  WordBool        = $0000
  LongBool / BOOL = $00000000

Bei Free Pascal kommen dann noch QWordBool, Boolean16, Boolean32 und Boolean64 (letztere drei seit 2.6.0) hinzu :mrgreen:

Code:

True:
  QWordBool       = $FFFFFFFFFFFFFFFF
  Boolean16       = $0001
  Boolean32       = $00000001
  Boolean64       = $0000000000000001  

False:
  QWordBool       = $0000000000000000
  Boolean16       = $0000
  Boolean32       = $00000000
  Boolean64       = $0000000000000000

Gruß,
Sven

[Medium]

Letztlich ist wohl auch unter C(++) der direkte Vergleich genau so kritisch wie in Delphi. Vor allen Dingen kann bei einem nackten "if mybool then" ein schlankes "jz" bzw. "jnz" erzeugt werden, ohne vorher noch ein "cmp" zu machen, sowie den Vergleichswert zu laden oder verpointern.
Und da eben letztlich immer ein jz oder jnz mitspielt, ist ein "if 0" immer der richtige weg, und ein "if not 0" die logische Konsequenz. Dabei tritt dann nur eben das Problem auf, dass Datentypen breiter als 1 Bit sind, und sich somit je nach Architektur beliebig viele "nicht nulls" bilden ließen. Auch in C-likes, und daher ist auch da zumindest ein "== true" eher smelly.
Interessant finde ich, dass man für beide o.g. True-Konstrukte ($FFFFFFFF und 1) logisch und semantisch sinnvoll argumentieren kann, wobei beides bei vernünftiger Verwendung (kein Vergleich machen) auch problemlos gemischt benutzt werden kann. Delphi geht den "mathematischen" Weg 0-1, C den technischen, bei dem einfach das "not" als logischer Operator auf den gesamten Operanden angewendet wird.