Zuweisen und rechnen

So jetzt sind wir beim Thema Zuweisen und Rechnen.

Zuweisen ist ja noch einfach. Haben wir auch schon mal gemacht. Einer Variable einen Wert z.B. a = 14; oder auch einer Variablen eine andere a = b;
Auch die Rückgabewerte von Funktionen landen normalerweise in einer Variablen a = digitalRead(SWITCH_PIN);

Was man jedoch nicht verwechseln sollte, ist die hier beschrieben Zuweisung a = b und der Vergleich a == b. Das gibt immer wieder Probleme. Vorallem wenn man sowas schreibt:

if (a = b) {… solange b > 0 ist ist die Bedingung erfüllt. Leider ist danach der Wert von a weg. Richtig müßte es so heißen: if (a==b) {…

Hab noch ein abschrekendes Beispiel, von einen User aus dem Schiffmodellforum:

String s;
int a, b, c; 
a=b=c=0; 
if(a==b==c) s = "Du Depp"; else s = "braves Kind";

Was steht danach in s?

Zunächst rechnen wir mal bitweise.

a = a & b // bitweises logisches UND

//a = 0 1 0 1 (5)
//b = 0 0 1 1 (3)
//-----------
//a = 0 0 0 1 (1)

a = a | b // bitweises logisches ODER

//a = 0 1 0 1 (5)
//b = 0 0 1 1 (3)
//-----------
//a = 0 1 1 1 (7)

a = a ^ b // bitweises logisches XODER

//a = 0 1 0 1 (5)
//b = 0 0 1 1 (3)
//-----------
//a = 0 1 1 0 (6)

a ~= a; // bitweises NICHT

//a = 0 1 0 1 (5)
//-----------
//a = 1 0 1 0 (10)

a = a >> b; // bitweises schieben nach rechts

//b = 2
//a = 0 0 0 0 1 0 1 0 (9)
//-------------------
//a = 0 0 0 0 0 0 1 0 (2)

a = a << b; // bitweises schieben nach links

//b = 2
//a = 0 0 0 0 0 1 0 1 (5)
//-------------------
//a = 0 0 0 1 0 1 0 0 (40)

Wie man leicht sieht, bitweisen schieben ist wie multiplizieren und dividieren mit 2, nur deutlich schneller.

Rechnen aber auch. addieren ist +, subtrahieren ist -, multiplizieren ist *, dividieren ist /. Alles ganz easy. Es gibt aber auch noch sowas %. Das ist der Rest einer Division. Beispiel: 

9 / 4 = 2
9 % 4 = 1 (denn 2×4 = 8 plus 1 = 9)

Einfach gell. Beispiele:

a = 21 + 21 // a = 42
a = 63 - 21 // a = 42

a = 6 * 7 // a ist danach auch 42

b = 6;
a = 7 * b // wer hätte das gedacht a ist wieder 42

b = 126;
a = b / 3 // und schon wieder 42

b = 162;
a = b % 60 // nicht schon wieder 42

Sollte man eigentlich vermeiden, geht aber nicht immer. Arduino macht das schon für dich richtig, meistens jedenfalls. Aber gerade wenn mal Ganzzahl und Fliesskommazahlen mischt, kann das Ergebniss nicht so aussehen wie man es erwartet hat. Auch mit Überläufen im Wertebereich muss man vorsichtig sein. 255 + 10 in ein Byte gespeichert ist eben nicht 265, sondern 9.

Es gibt ein paar spezielle Rechnungen, die einem die Schreibarbeit erleichtern, aber leider teilweise unleserlich sind. (Finde ich)

a++; // ist eigentlich a = a + 1, das kann man sich gut merken.
a--; // ist a = a - 1; Auch noch einleuchtent.

b = ++a; // a = a + 1; b = a; (Das geht mit - genauso...)
b = a++; // b = a; a = a +1; Hier hat b den alten wert von a.

a += b; // ist eigentlich a = a + b;
a -= b; // ist ja dann logisch, gibt's auch mit * und /

a &= b; // bitweises logisches UND

//a = 0 1 0 1
//b = 0 0 1 1
//-----------
//a = 0 0 0 1

a |= b; // bitweises logisches ODER

//a = 0 1 0 1
//b = 0 0 1 1
//-----------
//a = 0 1 1 1

Berechungen mit long und float werden, im Gegensatz zu den Berechnung mit int, byte word usw., durch die Hardware nicht unterstützt. Deswegen dauern berechnungen damit deutlich länger. Deswegen sollte man auf Berechnungen damit, wann immer es möglich ist, verzichten.