Inkrementieren/Dekrementieren

[Marion (Gast)]

Hallo,

kann man das noch weiter verbessern?

    const uint16_t maxShift = 359;
    static int16_t shift = 0;
    const int16_t step = 85;

    if(step > 0)
    {
      shift = (shift + step) % maxShift+1;
    }
    else if(step < 0)
    {
      if(shift - step < 0) shift = maxShift - (shift - step);
      else shift = (shift - step);
    }

[Johann L. (gjlayde)]

Kommentieren / Dokumentieren, was das soll.

[faultier (Gast)]

Marion schrieb:
> Hallo,
>
> kann man das noch weiter verbessern?

Hallo, ja!

[Marion (Gast)]

Möchte eine Variable hoch oder runterzählen lassen, je nachdem ob step 
positiv oder negativ ist. Der Werte Bereich soll dann von 0 - 359 (inkl. 
Überlauf) gehen.

[Wolfgang (Gast)]

Marion schrieb:
> kann man das noch weiter verbessern?

Das kommt auf die verfügbare Hardware und auf das Kriterien für "besser" 
an.

[Karl H. (kbuchegg)]

Marion schrieb:

>       shift = (shift + step) % maxShift+1;

Da maxShift hier wohl im allgemeinen Fall keine 2-er Potenz sein wird, 
würde ich dir hier von einer % Operation abraten. Das +1 dürfte hier 
auch falsch sein, es sei denn du machst da eine Klammer drum herum

        shift += step;
        while( shift > maxShift )
          shift -= maxShift + 1;

das hier

>     }
>     else if(step < 0)
>     {
>       if(shift - step < 0) shift = maxShift - (shift - step);
>       else shift = (shift - step);
>     }

ist mir ehrlich gesagt zu gekünstelt. Da du sowieso mit Vorzeichen 
rechnest:

       shift += step;
       while( shift < 0 )
         shift += maxShift + 1;

Ob da jetzt jeweils eine Korrektur um +1 sein muss oder nicht, hängt 
davon ab, ob der Wert maxShift auch erlaubt ist oder nicht. Ich würde 
allerdings hier nicht in den Berechnungen immer +1 rechnen, sondern den 
Wert maxShift an sich um 1 höher halten. Lässt sich ja einfach beim 
Setzen bzw. Auslesen des Wertes berücksichtigen. Der Grund ist simpel: 
den Wert verändern wird man wohl eher selten, jedoch häufiger anwenden. 
Dann spar ich dem µC beim Anwenden das ständige +1 dazurechnen, während 
es beim Verändern als Operation unter "ferner liefen" fungiert.

[Karl H. (kbuchegg)]

Karl H. schrieb:

> Da maxShift hier wohl im allgemeinen Fall keine 2-er Potenz sein wird,
> würde ich dir hier von einer % Operation abraten.


Edit:
Es sei denn natürlich, dein unbekannter Computer kann Divisionen in 
Hardware durchführen.

[Marion (Gast)]

Ja, die Klammer hat gefehlt.

[Clemens L. (c_l)]

% bindet stärker als + (und da helfen Leerzeichen auch nicht, der 
Compiler will Klammern sehen).

Und auch bei negativem step wäre eine Addition richtig.

Viel einfacher so:

shift += step;
if (shift < 0)
  shift += maxShift+1;
else if (shift > maxShift)
  shift -= maxShift+1;