Wann wird dieser Ausdruck false ?

[Roger K. (roschee)]

Hallo,

wenn ich folgenden Ausdruck so schreibe funktioniert er nicht.
FLAGS ist ein Integer, mit dem ich ein 8bit Feld machen will.

 if ((FLAGS & 0b10000000)==1)

nur wenn ich ihn so schreibe if (FLAGS & 0b10000000)


Ich wollte die obige Schreibweise nur deswegen verwenden, da ich den 
etwas
groesseren Vergleich unten auf 0 abfragen moechte und ich aber nicht 
weiss,
wie ich ihn noch anderst schreiben kann. So wie er aktuell ist, 
funktioniert er aber nicht richtig.

if ((PIND == 0b11111101) & ((FLAGS & 0b01000000)==0))


Gruss

Roger

[gast (Gast)]

> if ((FLAGS & 0b10000000)==1)

Wird nie erfüllt.

eventuell so:
if ((FLAGS & 0b10000000)==0b10000000)

oder so:
if ((FLAGS & 0b10000000)>=1)

[gast (Gast)]

weil FLAGS & 0x80 entweder 0x80 oder 0 ergibt.

[Matthias (Gast)]

Über diese Kleinigkeit stolpert man schnell mal.

Die Grundlagen der Bitmaskierung sind wohl nicht ganz so geläufig.
Wenn Du (FLAGS & 0b10000000) maskierst, dann kommt entweder 0 raus
oder 128d bzw. 0x80. Das Bit wird zwar ausgeschnitten, bleibt aber an 
seiner
Position (Bit7) und behält damit auch seine Wertigkeit von 2^7 (sprich: 
2 hoch 7). Dann kann man lange auf == 1 vergleichen!

Ohne das "==1" funktioniert es, weil alles größer 0 als "true" 
interpretiert wird. Nur 0 ist "false". Deshalb wundert man sich schnell 
mal, wenn man
auf "==true" vergleicht. Das ganze wird wahrscheinlich auch noch vom 
compiler abhängen.

[Jörg W. (dl8dtl) (Moderator)]

gast wrote:

> eventuell so:
> if ((FLAGS & 0b10000000)==0b10000000)
>
> oder so:
> if ((FLAGS & 0b10000000)>=1)

Oder

if ((FLAGS & 0b10000000) != 0)

Hässlicher:

if (FLAGS & 0b10000000)

[gast (Gast)]

bte, geht eigentlich auch? ;)

if ((FLAGS & 0b10000000) < 0)

[Ahem (Gast)]

>if ((FLAGS & 0b10000000) < 0)

Was heisst gehen?

Es ist syntaktisch korrekt aber gleich wertig zu

if (FLAGS & 0b10000000)

da das Schieben um 0 Bit nach links eben keinen Effekt hat.

[Ahem (Gast)]

Oohhh. So ein Sch....
Sorry.

Natürlich ist das ein einzelnes <.

Das geht schon wenn FLAGS ein Vorzeichenbehafteter Typ ist.

[Roger K. (roschee)]

Besten Dank Euch allen fuer die sofortige Hilfe.

[gast (Gast)]

> if ((FLAGS & 0b10000000) < 0)
war nicht ganz ernst gemeint (und 'bte' sollte 'btw' - by the way 
heissen;) )


Noch ein kleiner Tip falls du öfters im Code Bits in Flags testen 
willst, ich nehme gerne #define Makros dafür.

in der art wie zB:

#define IS_ALL_BIT(f,bm) ((f&bm)==bm)
#define IS_ONE_BIT(f,bm) ((f&bm)!=0)

für zB:

 if IS_ALL_BIT(myflag,MY_FLAGBIT_3|MY_FLAGBIT_8)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Jörg Wunsch wrote:
> Hässlicher:
> if (FLAGS & 0b10000000)
Über Schönheit lässt sich streiten ...  ;-)
Aber du hast Recht, so richtig schön ist es erst mit der Hex-Zahl:

if (FLAGS & 0x80)

[Peter D. (peda)]

Jörg Wunsch wrote:

> Hässlicher:
>
> if (FLAGS & 0b10000000)

Ich schreib lieber:

if (FLAGS & 1<<7)

oder wenns andersrum sein soll:

if (!(FLAGS & 1<<7))

Peter

[Simon K. (simon)]

> if (FLAGS & 1<<7)

Ich find schöner

if (FLAGS & (1<<7))

Da muss man weniger Angst um Operatorvorrang haben.

[Peter D. (peda)]

Simon K. wrote:
> if (FLAGS & (1<<7))
>
> Da muss man weniger Angst um Operatorvorrang haben.

Der Compiler kennt die Vorrangregeln, da muß man keine Angst haben.

Nur wenn man sich selber unsicher ist, sollte man Klammern nehmen.


Peter

[P. S. (Gast)]

Peter Dannegger wrote:

> Nur wenn man sich selber unsicher ist, sollte man Klammern nehmen.

Code sollte auch fuer andere leicht und schnell lesbar sein. Der 
naechste Entwickler hat vieleicht nicht Vorrangregeln, sondern Templates 
oder sonstwas als Hobby...

[Rocky (Gast)]

Hi,

bei Bitmasken wertet man immer <> 0 aus...
zumindest wenn auf Boolsche Werte überprüft werden soll.

Grüße Rocky

[Norgan (Gast)]

> bei Bitmasken wertet man immer <> 0 aus...

Oh wie ich solche Hausfrauen-Programmierrezepte "liebe". Bei Bitmasken 
wertet man das aus, was man auswerten will. Wenn der Algorithmus es 
erfordert auch == 0.

if((DATA & MASK) == 0)

beziehunggsweise

if(!(DATA & MASK))

ist völlig ok wenn der Test dem entspricht, was man wissen will.

Wenn man auf einem wilden Trip ist, gehen noch ganz andere Sachen. Zum 
Beispiel zuerst mit !! normalisieren um von Bit-Operationen auf logische 
Operationen umsteigen zu können.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Ich verwende gerne sprechende Variablennamen, z.B.

uint8_t EndschalterOben, EndschalterUnten;

Eine Schreibweise wie

  if (EndschalterOben) {
  }
  if (EndschalterUnten) {
  }

ist immer noch hübscher lesbar als

  if (EndschalterOben!=0) {
  }

Und ganz extrem wirds bei Abfragen wie

  if (EndschalterOben=0) {
  }

Nach so einem Fehler sucht manch einer lang.... ;-)

@  Norgan
> zuerst mit !! normalisieren
Sieh dir mal an, was der Compiler daraus macht  :-o
Fazit: Ich bin von dem Trip abgekommen...

[... (Gast)]

if (EndschalterOben=0) {
}

... eigentlich sucht man überhaupt nicht lange nach derartigen Fehlern, 
da einem der GCC eine Warnung um die Ohren haut. Vorrausgesetzt 
natürlich, man hat sie nicht ausgeschaltet oder ignoriert sie einfach.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

> ... der GCC ...
Ja, und andere Compiler?

> ... eine Warnung ...
> ... man ignoriert sie einfach.
Genauso wie die 147 anderen auch... :-/