Verständnissfrage: negierte Bitabfrage in If-Anweisung

[Jeffrey L. (the_dude)]

Hallo,
mal eine Frage an Leute die C schon länger und (hoffentlich) besser als 
ich programmieren können.

Was ist programmiertechn. "sauberer" gelöst? welche der beiden 
Variationen würdet Ihr verwenden und wieso?

(Plan B: ...oder ist das eigentlich sch...-egal???)

so:

If (! (var & BIT_1))

oder so:

If (var & ~BIT_1)

[Dergute W. (derguteweka)]

Moin,

Die, die das macht, was ich eigentlich erreichen will. Wurscht, wie's 
aussieht.

Gruss
WK

[Jeffrey L. (the_dude)]

naja, wenn man etwas neues lernt, sollte man es doch gleich von Anfang 
an richtig machen.

Interpretiert ein compiler die beiden codezeilen unterschiedlich?

Natürlich geht auch das Prinzip "Mach ich immer so, hat bisher immer 
irgendwie geklappt..."

[Joachim B. (jar)]

Jeffrey L. schrieb:
> welche der beiden
> Variationen würdet Ihr verwenden und wieso?

ich habe ja kaum Ahnung aber

Jeffrey L. schrieb:
> BIT_1

ist BOOL kann ja nur high oder low sein

ergo würde ich auf TRUE oder FALSE abfragen was halt gewünscht ist

Jeffrey L. schrieb:
> var

kann ja alles mögliche sein und Jahre später weiß keiner mehr was sich 
der Autor dachte

[Jeffrey L. (the_dude)]

das war jetzt ja doch nur ein stilisiertes Beispiel.
Das spielt jetzt doch überhaupt keine Rolle was 'var' ist und welches 
BIT ich abfrage!




Konkret im code würde das jetzt vlt. so aussehen:
gefällt Dir das besser?

if (u16CPU_RegisterAHBP & ~SPI_FLAG_CS)

if (! (u16CPU_RegisterAHBP & SPI_FLAG_CS))

[Joachim B. (jar)]

Jeffrey L. schrieb:
> gefällt Dir das besser?

nö ist ohne ins Datenblatt zu schauen nichtssagend!

[Mikro 7. (mikro77)]

Dir ist klar dass das zwei verschiedene Bedingungen sind?

1: Ist irgendwas gesetzt -- ohne CS zu berücksichtigen
3: Ist CS nicht gesetzt

[Jeffrey L. (the_dude)]

Mikro 7. schrieb:
> Dir ist klar dass das zwei verschiedene Bedingungen sind?


Genau! um das geht es.
Die Abfrage bezieht sich darauf, ob in dem Nocken bzw. Register das eine 
Bit gesetzt ist oder eben nicht.

Beide Abfrage sind erfüllt, wenn BIT1 nicht gesetzt ist, ergo springt 
der code beides mal in die Bedingung hinein.

ich vermute, dass zeile 3 schnell geprüft ist? - könnte aber auch stark 
compilerabhängig sein?

...eignetlich will ich wissen wie man es in der praxis schreibt, wenn 
man eben nur das eine Bit abfragen möchte und die anderen Bits "egal" 
sind.

[Johann L. (gjlayde)]

Jeffrey L. schrieb:
> so:
>

If (! (var & BIT_1))

>
> oder so:
>

If (var & ~BIT_1)

Ich verstehe die Frage nicht; die beiden Bedingungen sind ja nicht 
gleichbedeutend.

Die erste Bedingung schaut sich die Bits von var an, die in BIT_1 sind.

Die zweite Bedingung schaut sich die Bits von var an, die NICHT in BIT_1 
sind.

Beispiel: var = 11, BIT_1 = 10

1) var & BIT_1 = 10  =>  !(var & BIT_1) = false

2) var & ~BIT_1 = 01 = true

[Jeffrey L. (the_dude)]

Aber 1 wird nochmal negiert!

und dann sind 1 und 2 wieder im Ergebnis gleichwertig, oder doch nicht?

[Klaus (feelfree)]

Jeffrey L. schrieb:
> Beide Abfrage sind erfüllt, wenn BIT1 nicht gesetzt ist

Nein.

[Jeffrey L. (the_dude)]

Mit BIT_1 meine ich wirklich BIT1, keine "willkürliche" variable...
BIT_1 ist 0x01.

BIT_2 0x02
BIT_3 0x04


If (! (var & 0x01))
If (var & ~0x01)

[Peter D. (peda)]

Jeffrey L. schrieb:
> If (var & ~0x01)

Bedeutet:
if (var & 0xFE)

[Jeffrey L. (the_dude)]

Peter D. schrieb:
> Jeffrey L. schrieb:
>> If (var & ~0x01)
>
> Bedeutet:
> if (var & 0xFE)

jup!
und meine Frage eben wo liegt der Unterschied zu
If (! (var & 0x01))

if    (var & 0xFE)

If (! (var & 0x01))

[Thorsten M. (pappkamerad)]

Jeffrey L. schrieb:
> Konkret im code würde das jetzt vlt. so aussehen:
> gefällt Dir das besser?
>

> if (u16CPU_RegisterAHBP & ~SPI_FLAG_CS)
> 
> if (! (u16CPU_RegisterAHBP & SPI_FLAG_CS))
>

Die Tücke beim ersten ist, dass das nur funktioniert, wenn im Register 
noch andere Bit wie das gesuchte gesetzt sind. Ist das Register = 0x00, 
dann ergibt sich
if (0 & ~SPI_FLAG_CS)... also
if (0) ... wird also nicht betreten, obwohl das gesuchte Bit nicht 
gesetzt ist.

[Johann L. (gjlayde)]

Jeffrey L. schrieb:
> Mit BIT_1 meine ich wirklich BIT1, keine "willkürliche" variable...
> BIT_1 ist 0x01.

Es spielt keine Rolle, ob BIT_1 nur 1 Bit gesetzt hat oder mehrere. 
Wenn es für 0x01 nicht funktioniert, dann findet man auch Fälle, so dass 
es für 0x02 nicht funktioniert: Man braucht nur Bit 0 mit Bit 1 zu 
tauschen.

Mach doch einfach mal ein Programm, dann siehst du dass die Bedingungen 
nicht äquivalent sind:

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>

int main (void)
{
    uint8_t BIT_1 = 0x01;
    uint8_t var = 0;
    do
    {
        bool b1 = ! (var & BIT_1);
        bool b2 = var & ~BIT_1;
        if (b1 != b2)
            printf ("var=0x%x: b1 = %d, b2 = %d\n", var, b1, b2);
    } while (++var);

    return 0;
}

var=0x0: b1 = 1, b2 = 0
var=0x3: b1 = 0, b2 = 1
var=0x5: b1 = 0, b2 = 1
var=0x7: b1 = 0, b2 = 1
var=0x9: b1 = 0, b2 = 1
var=0xb: b1 = 0, b2 = 1
var=0xd: b1 = 0, b2 = 1
var=0xf: b1 = 0, b2 = 1
var=0x11: b1 = 0, b2 = 1
var=0x13: b1 = 0, b2 = 1
var=0x15: b1 = 0, b2 = 1
var=0x17: b1 = 0, b2 = 1
var=0x19: b1 = 0, b2 = 1
var=0x1b: b1 = 0, b2 = 1
var=0x1d: b1 = 0, b2 = 1
...

[Klaus (feelfree)]

Jeffrey L. schrieb:
> und meine Frage eben wo liegt der Unterschied zu

> If (! (var & 0x01))
Ist erfüllt, wenn BIT_1 nicht gesetzt ist

> if    (var & 0xFE)
Ist erfüllt, wenn ein mindestens eines der Bits 0, 2..7 gesetzt ist.

Also 2 völlig verschiedene Dinge.

[Rainer W. (rawi)]

Jeffrey L. schrieb:
> Konkret im code würde das jetzt vlt. so aussehen:
> gefällt Dir das besser?
>
> if (u16CPU_RegisterAHBP & ~SPI_FLAG_CS)
>
> if (! (u16CPU_RegisterAHBP & SPI_FLAG_CS))

Jeffrey L. schrieb:
> welche der beiden Variationen würdet Ihr verwenden und wieso?

Das kommt drauf an, was du erreichen willst. Fest steht, dass die beiden 
Ausdrücke ein völlig verschiedenes Ergebnis liefert. Guck dir die 
Minimalversion mit je zwei Bit an.

0b11 & ~0b01 liefert 0b10, also true
!(0b11 & 0b01) liefert !0b01, also false

[Rbx (rcx)]

Normalerweise brütet man konzentriert über eine Wertetabelle, probiert 
ein paar Zusammenhänge aus, ..und weiß hinterher einigermaßen, was zu 
tun ist bzw. wie gewisse Zusammenhänge und Sonderzeichen im 
Bool-Zusammenhang einzuordnen sind.

C und Bool sind ja nun auch nicht die besten Freunde, wo dann gut ist, 
die ein oder andere gute Praxisdokumentation zu finden:
https://www.cs.uic.edu/~jbell/CourseNotes/C_Programming/Decisions.html

Typische Boolzusammehänge sind auch nicht immer so leicht auf einen 
Blick zu verstehen. Weswegen Papier und Bleistift auch eine (sehr) gute 
Hilfe sein können.

[Simon G. (sigro)]

//! Liefert true, wenn das Bit gesetzt ist
#define bit_is_high(reg, bit) (((reg) & BV(bit)) != 0U)
//! Liefert true, wenn das Bit gelöscht ist
#define bit_is_low(reg, bit)  (((reg) & BV(bit)) == 0U)

if(bit_is_high(var, 1))

if(!bit_is_high(var, 1))

so habe ich das mal gemacht.

[Harald K. (kirnbichler)]

Simon G. schrieb:
> so habe ich das mal gemacht.

Wenn Du schon ein Macro namens "bit_is_low" definierst, warum nutzt Du 
stattdessen ein invertiertes "bit_is_high"?

[Norbert (der_norbert)]

Zurück zur Frage:
Um in einem beliebig mit Bits besetzen Register auf ein einzelnes Bit zu 
testen:

#define BIT(x)  (1U<<x)

!!(value & BIT(3)) // liefert 1 (und nur 1) wenn das Bit gesetzt ist.
 !(value & BIT(3)) // liefert 1 (und nur 1) wenn das Bit gelöscht ist.

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

Norbert schrieb:

> #define BIT(x)  (1U<<x)

Fehler: x ist auf der rechten Seite nicht geklammert. Wenn du dann sowas 
machst:

BIT(a > b? a: b)

kommt etwas völlig unerwartetes raus.

> !!(value & BIT(3)) // liefert 1 (und nur 1) wenn das Bit gesetzt ist.

Wobei sich die Frage stellt, wo man das braucht. Wenn es schon auf die 
Zahl 1 ankommt, würde ich das explizit hinschreiben:

(value & BIT(3))? 1: 0

Wenn es nur die Abfrage einer Bedingung ist, ist es nicht wichtig, ob 
das genau 1 ist oder irgendwas anderes von 0 verschiedenes.

[Norbert (der_norbert)]

Jörg W. schrieb:
> Fehler

Ja, war einfach schnell hin getippt. Doch genau darauf kam es bei der 
Frage aber auch gar nicht an. Sondern nur zur Verdeutlichung, dass man 
ein Bit an verschiedenen Positionen haben kann!

Jörg W. schrieb:
> Wobei sich die Frage stellt, wo man das braucht.

Manchmal möchte man sich einen "aufgeräumten" boolschen Wert sichern. 
Und ›0‹ oder ›1‹ passt dann sogar in ein u_int8 hinein. Oder, auch 
schön, in ein Bitfield.

Aber wie immer kann man die Aufgabe natürlich auf zig Arten lösen.

[Bruno V. (bruno_v)]

Jörg W. schrieb:
> Wenn es schon auf die Zahl 1 ankommt, würde ich das explizit hinschreiben:

Hier geht es m.E. eher um die Repräsentation von true (auch wenn beides 
1 ist)

 * !! --> beliebiger Ausdruck zu Boolean
 * ?1:0 --> Wertepaar, nicht boolean (Boolean kann einfacher erfolgen)

[Dergute W. (derguteweka)]

Geilo,

Endlich mal wieder Profiinformatiker beim Trockenschwimmen...

scnr,
WK

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

Norbert schrieb:
> Und ›0‹ oder ›1‹ passt dann sogar in ein u_int8 hinein.

bool passt auch in 8 Bit. stdbool.h is your friend. bool wandelt auch 
gleich noch automatisch alles in true und false um, d.h. der Datentyp 
kann (wenn man ihn nicht irgendwo vergewaltigt) nur diese beiden Werte 
annehmen.