Anfänger: Wert bei jedem Durchlauf zwischen 0 und 1 hin und her wechseln

[Paul (Gast)]

Hallo Forengemeinde,

ich versuche eine Variable bei jedem Programmdurchlauf zwischen 1 und 0 
hin und her zu wechseln.

while(1) {
 Boolean = Boolean + 1

switch (Boolean)
{
    case 0:
        mache etwas
        break;

    case 1:
        mache etwas anderes
        break;

}
}

Jetzt lese ich jedoch hier:

http://rn-wissen.de/wiki/index.php/C-Tutorial#Boolean_.28Logische_Variablen.29

das es solche Wahrheitstypen nicht gibt.

Wie macht man es denn dann mit "int"? Kann mir das jemand bitte an einem 
kleinen Beispiel mal zeigen?

MfG Paul

[Nils (Gast)]

Die Antwort steht praktisch in dem Link, den du selber gepostet hast:

    int a;
    if   (a)  {printf("a ist TRUE")}     // hat gleiche Wirkung wie
    if (a!=0) {printf("a ist TRUE")}

Also:       Integerausdruck = 0 ist FALSE
            Integerausdruck !=0 ist TRUE





MfG Nils

[Tom (Gast)]

Das Tutorial ist sehr alt oder bezieht sich auf veraltete¹ Compiler. 
bool gibt es schon länger in <stdbool.h>

Wenn man bool will und der Compiler bool kann, sollte man bool nehmen, 
statt ein umständliches Ersatzkonstrukt zu bauen.

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

int main(void)
{
    bool led_is_on = false;
    for (int i = 0; i < 10; ++i)
    {
        if (led_is_on)
        {
            printf("an\n");
        }
        else
        {
            printf("aus\n");
        }
        led_is_on = !led_is_on;
    }
    return 0;
}

¹gerade kommerzielle Embedded-Compiler brauchen ca. 20 Jahre länger als 
der Rest der Welt, um Sprachstandards umzusetzen.

[echter MSPler (Gast)]

int value = 0;
...
value = 1 - value;  // toggle value

[Paul (Gast)]

led_is_on = !led_is_on

war die Lösung die ich gesucht habe.
Gerade als Anfänger hat man solch einfache Dinge nicht immer gleich auf 
parrat.

Danke!

[lrep (Gast)]

Tom schrieb:
> Wenn man bool will und der Compiler bool kann, sollte man bool nehmen,
> statt ein umständliches Ersatzkonstrukt zu bauen.

Ja, vor allem weil so etwas:

Paul schrieb:
> while(1) {
>  Boolean = Boolean + 1

nicht nur nicht den gewünschten Effekt hat, sondern in Bälde einen 
Überlauf liefern wird.

[Paul (Gast)]

Gerade mal "Überlauf" angeguckt - danke für den Tip

[echter MSPler (Gast)]

Paul schrieb:
> led_is_on = !led_is_on

Achtung! Der Tipp galt für boolean. Mit int geht das auch, ist aber 
unsauber: es wird einer Ganzzahl ein Wahrheitswert zugewiesen.

[Peter II (Gast)]

lrep schrieb:
>>  Boolean = Boolean + 1
>
> nicht nur nicht den gewünschten Effekt hat, sondern in Bälde einen
> Überlauf liefern wird.

nein macht es nicht. In einer Rechnung liefert ein bool immer 0 oder 1 
zurück. Damit bleibt es auf 1.

[Marc V. (Firma: Vescomp) (logarithmus)]

echter MSPler schrieb:
> int value = 0;
> ...
> value = 1 - value;  // toggle value

 LOL.
 Schuster, bleib bei deinem Leisten.

[jo mei (Gast)]

Marc V. schrieb:
> echter MSPler schrieb:
>> int value = 0;
>> ...
>> value = 1 - value;  // toggle value
>
>  LOL.
>  Schuster, bleib bei deinem Leisten.

Was ist daran so verkehrt?

[Karl Käfer (Gast)]

Hallo Paul,

Paul schrieb:
> ich versuche eine Variable bei jedem Programmdurchlauf zwischen 1 und 0
> hin und her zu wechseln.

int a = 0;

while(true) {
  a = 1 - a;
}

HTH,
Karl

[Marc V. (Firma: Vescomp) (logarithmus)]

jo mei schrieb:
> Marc V. schrieb:
>> echter MSPler schrieb:
>>> int value = 0;
>>> ...
>>> value = 1 - value;  // toggle value
>>
>>  LOL.
>>  Schuster, bleib bei deinem Leisten.
>
> Was ist daran so verkehrt?

 Author.

[c-hater-hater (Gast)]

echter MSPler schrieb:
> ist aber
> unsauber: es wird einer Ganzzahl ein Wahrheitswert zugewiesen.
Wieso das?
In C ist es klar definiert, dass
 !(ungleich 0) == 0
und
 0! == 1
ist.

[ich (Gast)]

int x = 0;

while(1)
{
    x = ~x & 0x01
}

du kannst mit ~ invertieren
mit & kannst du dann maskieren

Gruß

[Peter II (Gast)]

ich schrieb:
> du kannst mit ~ invertieren
> mit & kannst du dann maskieren

braucht man aber nicht

x = ~x

reicht genauso.

[echter MSPler (Gast)]

jo mei schrieb:
> Marc V. schrieb:
> echter MSPler schrieb:
> int value = 0;
> ...
> value = 1 - value;  // toggle value
>
>  LOL.
>  Schuster, bleib bei deinem Leisten.
>
> Was ist daran so verkehrt?

Nix und sogar typsicher. Im Profibereich eine Standardlösung.

[c-hater-hater (Gast)]

Peter II schrieb:
> braucht man aber nicht
> x = ~x
Dann togglet aber jedes bit von x und nicht nur das LSB.
Also z.B.  1 <--> -2  oder  0 <--> -1.
So würde es aber gehen:

int x = 0;
//…
x ^= 1;

[echter MSPler (Gast)]

c-hater-hater schrieb:
> Peter II schrieb:
> braucht man aber nicht
> x = ~x
>
> Dann togglet aber jedes bit von x und nicht nur das LSB. Also z.B.  1
> <--> -2  oder  0 <--> -1.
> So würde es aber gehen:int x = 0;
> //…
> x ^= 1;

Nach Neandertallogik wäre es OK
int x = O;
...
x = ~x;

Der gleiche Scheiss, den du hier schreibst.

[OldMan (Gast)]

Ein anderer Lösungsansatz wäre:

#include <stdio.h>

int main(void) {
  int x,i;
  x = 1;
  for (i=0; i < 5; i++)
      printf("%d  ", x ^= 1);
  return 0;
}

[c-hater-hater (Gast)]

echter MSPler schrieb:
>> x ^= 1;
>
> Nach Neandertallogik wäre es OK

Kannst du das mal erklären?

[echter MSPler (Gast)]

Du, als C Verächter, schreibst, alles ausser 0 ist true. Es spielt also 
keine Rolle, wieviel Bits gekippt werden.

Ich schreibe: Nimm die typsichere Lösung. Geht immer, C, C++ und was 
sonst noch gefällt.

Zahl = Zahl;

Boll = Boll;

[c-hater-hater (Gast)]

Hab ich da was verpasst? Will der TE jetzt nicht mehr zwischen 0 und 1 
togglen?

Das mit dem XOR 1 sollte auf jeden Fall funktionieren, bei Bool (falls 
Boll == Bool) und auch bei int. Gleich wie var = !var; was IMHO die 
beste Lösung ist.

[echter MSPler (Gast)]

Ihm gehts um Bool, darum funktioniert das in den verschiedenen 
Varianten.
Man sollte aber trotzdem Zahlen und Logik trennen, typischer 
programmieren. Aber das ist wohl eher ein Problem der Profis. ;-)

[Marc V. (Firma: Vescomp) (logarithmus)]

echter MSPler schrieb:
> Du, als C Verächter, schreibst, alles ausser 0 ist true. Es spielt also
> keine Rolle, wieviel Bits gekippt werden.

 So ist es definiert, überall.
 Nur Null ist false, alles andere ist true.

 Somit ist:
 false = 0;
 true = !false;
 oder:
 true <> false;

 Schuster, bleib bei deinem Leisten.