rechnen mit dem Ergebnis eines Vergleichs?

[ben (Gast)]

Hallo,

es geht um folgende Zeile:

vector[ptr+1][3]=vector[ptr+1][2]-(richtung==1)+(richtung==2);

Ich weiß das man es anders schreiben kann aber aufgrund der 
Übersichtlichkeit wollte ich es so schreiben. Warum funktioniert es 
nicht das man zu dem Wert aus vector[ptr+1][2] eins addiert wenn 
richtung==2 bzw. eins subtrahiert wenn richtung==1.

Gibt es eine Möglichkeit das zu machen ohne zwei if-Abfragen zu 
erstellen?

Müsste (richtung==1) nicht 1 bzw. 0 als Ergebnis der Abfrage liefern?


gleiches Problem weiter unten:

vector[ptr+1][3]=vector[ptr+1][2]+(richtung==4)-(richtung==3);

[Peter (Gast)]

ben schrieb:
> Müsste (richtung==1) nicht 1 bzw. 0 als Ergebnis der Abfrage liefern?

nein muss es nicht. Es muss 0 oder !0 liefern und !0 muss nicht 1 sein.

[Rolf Magnus (Gast)]

ben schrieb:
> Warum funktioniert es
> nicht das man zu dem Wert aus vector[ptr+1][2] eins addiert wenn
> richtung==2 bzw. eins subtrahiert wenn richtung==1.

Warum sollte es denn nicht funktionieren?

Peter schrieb:
> nein muss es nicht. Es muss 0 oder !0 liefern und !0 muss nicht 1 sein.

Nein. Ein Vergleich liefert immer 0 oder 1. Es wird lediglich umgekehrt 
dort, wo ein boolescher Wert erwartet wird, alles, was nicht 0 ist, als 
"true" interpretiert.

[ben (Gast)]

Peter schrieb:
> ben schrieb:
>> Müsste (richtung==1) nicht 1 bzw. 0 als Ergebnis der Abfrage liefern?
>
> nein muss es nicht. Es muss 0 oder !0 liefern und !0 muss nicht 1 sein.

Nagut das stimmt aber beim testen des Programms liefert es 
offensichtlich immer 0 egal welchen wert richtung hat.

[Klaus T. (gauchi)]

Du kannst mal das hier versuchen:

vector[ptr+1][3]=vector[ptr+1][2]+((richtung==1)?-1:((richtung==2)?+1:0))

(wahrscheinlich kann man da Klammern einsparen, aber da müsste ich jetzt 
über die Priorität des ?:-Operators nachdenken...)
aber ehrlich gesagt fände ich es so:

if(richtung == 1) {
  vector[ptr+1][3] = vector[ptr+1][2] - 1;
} else if(richtung == 2) {
  vector[ptr+1][3] = vector[ptr+1][2] + 1;
} else {
  vector[ptr+1][3] = vector[ptr+1][2];
}

oder so:

switch(richtung){
  case 1:
    vector[ptr+1][3] = vector[ptr+1][2] - 1;
    break;
  case 2:
    vector[ptr+1][3] = vector[ptr+1][2] + 1;
    break;
  default:
    vector[ptr+1][3] = vector[ptr+1][2];
}

übersichtlicher.

[Rolf Magnus (Gast)]

Wie wäre es mit:

vector[ptr+1][3] = vector[ptr+1][2];

if (richtung == 1)
    vector[ptr+1][3]--;

if (richtung == 2)
    vector[ptr+1][3]++;

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

Persönlich fände ich es deutlich übersichtlicher mit einem switch:

   ... temp;
   switch (richtung) {
     case 0: temp = vector[ptr+1][2]; break;
     case 1: temp = vector[ptr+1][2] - 1; break;
     case 2: temp = vector[ptr+1][2] + 1; break;
   }
   vector[ptr+1][3] = temp;

... wobei richtung vorzugsweise noch ein enum werden sollte.

Der sich daraus ergebende Code sollte bei einem vernünftigen Compiler
(wir sind ja im GCC-Forum ;-) identisch zu obigem "kompakten" Konstrukt
sein.

[ben (Gast)]

Ok es geht doch so wie ich im ersten Post geschrieben hab, ich Trottel 
hab nur vergessen richtung nach den benutzen auf 0 zu setzen und das hat 
einen  Fehler verursacht hat der so aus sah als ob +(richtung==x).

[(prx) A. K. (prx)]

ben schrieb:

> Gibt es eine Möglichkeit das zu machen ohne zwei if-Abfragen zu
> erstellen?

Deine Zeile wird je nach zugrundeliegender Maschine und Qualität des 
Compilers aufwendigeren Code erzeugen als if-Abfragen.

[ben (Gast)]

...nicht geht

[ben (Gast)]

A. K. schrieb:
> ben schrieb:
>
>> Gibt es eine Möglichkeit das zu machen ohne zwei if-Abfragen zu
>> erstellen?
>
> Deine Zeile wird je nach zugrundeliegender Maschine und Qualität des
> Compilers aufwendigeren Code erzeugen als if-Abfragen.

Dieser Abschnitt wird nur 2 mal alle ~160.000 Takte aufgeführt da hab 
ich es lieber übersichtlich und "langsam" als Komplizieren und schnell 
;-)

[(prx) A. K. (prx)]

ben schrieb:

> Dieser Abschnitt wird nur 2 mal alle ~160.000 Takte aufgeführt da hab
> ich es lieber übersichtlich und "langsam" als Komplizieren und schnell

... aber wenn du diesen Code in ein paar Jahren erneut ansiehst, dann 
wirst du den Sinn der if-Version wahrscheinlich deutlich schneller 
erfassen, als die Version mit den eingerechneten Vergleichen. Erst recht 
jeder andere Leser.

Dem kannst du natürlich entgegenwirken, indem du selbsterklärenden Code 
durch den verknoteten Ersatzcode und ausführlich erklärende Kommentare 
ersetzt ;-).

[R. M. (rmax)]

Ich weiß nicht, was mit "richtung" sonst noch passiert, aber evtl. läßt 
sich der übrige Code dahingehend anpassen, daß statt 1 und 2 die Werte 
-1 und 1 verwendet werden, dann kannst Du einfach schreiben:

vector[ptr+1][3] = vector[ptr+1][2] + richtung;

[ben (Gast)]

A. K. schrieb:

> ... aber wenn du diesen Code in ein paar Jahren erneut ansiehst, dann
> wirst du den Sinn der if-Version wahrscheinlich deutlich schneller
> erfassen, als die Version mit den eingerechneten Vergleichen. Erst recht
> jeder andere Leser.

Nagut aber wenn ich die 1 bis 4 die richtung neben 0 annehmen kann durch 
ein define mit hoch,runter,links,rechts ersetze dann kann ich den code 
sicher besser erfassen als mit noch einer if Schachtelungstiefe.
(mein koordinatenursprung ist oben links deswegen bei hoch -1 usw.)


@R. Max: Nein geht leider nicht, aber ich könnte richtung aufspalten in 
richtung_horizontal und richtung_vertikal, dann würde das funktionieren.