Mail to Code: Tutorial

Lernt, wie man den Code für Rechenknechte schreibt.

English version English Version

Rechenoperationen

Addition und Subtraktion

Zu den einfachsten Rechenoperationen zählen die Addition und die Subtraktion. Diese Operationen können entweder zwischen zwei Variablen oder zwischen einer Variablen und einem festen Wert vorgenommen werden. Sowohl bei der Addition als auch bei der Subtraktion ganzzahliger Werte ist das Ergebnis ebenfalls ein ganzzahliger Wert.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
// Define integer variables for some calcultaions
int variable_1 = 5;
int variable_2 = 7;
int result = 0;
 
void setup() {
 
}
 
void loop() {
  // initialize the variable
  result = 0;
 
  // ---------------------------------------
  // Ways to add values to a variable
  // ---------------------------------------
 
  // Add variable_1 to result
  result = result + variable_1;  // result is now 5
 
  // Add variable_2 to result
  result = result + variable_2;  // result is now 12
 
  // Add a fixed value to result
  result = result + 9;           // result is now 21
 
  // Short verion of adding a fixed vaule to a variable
  result += 11;                  // result is now 32
 
  // Short verion of adding two variables
  result += variable_2;          // result is now 39
 
  // Short version of adding "1" to a variable
  result++;                      // result is now 40
 
  // ---------------------------------------
  // Ways to subtract values from a variable
  // ---------------------------------------
 
  // Subtract variable_1 from result
  result = result - variable_1;  // result is now 35
 
  // Subtract variable_2 from result
  result = result - variable_2;  // result is now 28
 
  // Subtract a fixed value from result
  result = result - 9;           // result is now 19
 
  // Short verion of subtracting variable_2
  result -= variable_2;          // result is now 12
 
  // Short verion of subtracting a fixed vaule from a variable
  result -= 11;                  // result is now 1
 
  // Short version of subtracting "1" from a variable
  result--;                      // result is now 0
 
  // ---------------------------------------------
  // What is the result of the calculations below?
  // ---------------------------------------------
 
  variable_2 += variable_1;
 
  result = variable_1 - variable_2;
  result += 13 + 12;
  result--;
  result -= variable_1 + variable_2 + 33 - 5;
}
    

Überlauf bei Addition

Wie im Kapitel zu Variablen gezeigt, können Variablen immer nur einen festen Wertebereich abbilden. Was passiert aber, wenn das Ergebnis einer Rechenoperation außerhalb dieses Bereichs liegt? Betrachten wir diesen Vorgang anhand einer 8-Bit Ganzzahl ohne Vorzeichen (uint8_t):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void setup() {
 
}
 
void loop() {
  // Define integer variable for some calcultaions
  uint8_t result;
 
  // Set variable to maximum value
  result = 255;
 
  // Add 1 to the variable
  result += 1;
 
  // What number is now stored in "result"?
}
    

Betrachten wir die Rechenoperation aus obigem Programmbeispiel im Dualsystem:
  11111111 (255)
 +00000001 (  1)
 ---------
=100000000 (256)
Das Ergebnis passt nur in eine Speicherzelle mit mindestens 9 Bits, die Variable "result" ist allerdings nur als 8-Bit Speicher definiert. Das Programm bricht an dieser Stelle nicht ab, es werden aber lediglich die 8 niederwertigsten Bits als Ergebnis in die Variable übernommen. Diese 8 Bits sind 00000000, das Ergebnis der Addition ist für den Mikrocontroller also "0", auch wenn das nicht dem entspricht, was ihr im Schulunterricht gelernt habt. Die 8-Bit Variable ist auf Grund der Rechnung um das 9. Bit überglaufen, das nicht in das Speichergefäß passt und somit verloren geht.
Das gleiche gilt für sämtliche Rechnungen, deren Ergebnis nicht in den Speicherbereich der Zielvariablen passt:
  10011001 (153)
 +01110010 (114)
 ---------
=100001011 (267)
Hier ist das Ergebnis für den Mikrocontroller nicht 267, sondern 00001011, also 12, da erneut das 9. Bit verworfen wird.

Überlauf bei Subtraktion



<<< GPIO als digitaler Eingang
Inhaltsverzeichnis
Bitmanipulation >>>


Du findest diese Seite klasse?

Gummibärchen als Nervennahrung beim Programmieren und der Betrieb dieses Servers verschlingen mein Geld.
Helft mit einer Motivationsspritze, dieses Projekt am Laufen zu halten.

Klick hier oder scan den QR Code, um eine Spende zu überweisen.



Vielen Dank!

Fragen? Anregungen? Fehler gefunden?
Kontakt per E-mail: question@h1i1.de