C++-Programmierung/ Einführung in C++/ Rechnen (lassen)

Aus Wikibooks
Zur Navigation springen Zur Suche springen


In diesem Kapitel soll unser Rechner einmal das tun, was er ohnehin am besten kann: Rechnen. Wir werden uns derweil zurücklehnen und zusehen oder besser gesagt, werden wir das tun, nachdem wir ihm mitgeteilt haben, was er rechnen soll.

Einfaches Rechnen[Bearbeiten]

Nuvola-inspired-terminal.svg
1 #include <iostream>
2 
3 int main(){
4     std::cout << "7 + 8 = " << 7 + 8 << std::endl; // Ausgabe einer Rechnung
5 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 7 + 8 = 15

Zugegebenermaßen hätten Sie diese Rechnung wahrscheinlich auch im Kopf lösen können aber warum sollten Sie sich so unnötig anstrengen. Ihr Rechner liefert doch auch das richtige Ergebnis, und wenn Sie dies mit der Eingabe von Zahlen kombinieren, können Sie sogar bei jedem Programmdurchlauf zwei unterschiedliche Zahlen addieren:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     int summand1, summand2;                    // Anlegen von zwei Variablen
 5 
 6     std::cin >> summand1 >> summand2;          // Zwei Zahlen eingeben
 7 
 8     std::cout << summand1 << " + " << summand2 // beide durch " + " getrennt wieder ausgeben
 9               << " = "                         // " = " ausgeben
10               << summand1 + summand2           // Ergebnis berechnen und ausgeben
11               << std::endl;                    // Zeilenumbruch
12 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Benutzereingabe: 774
2 Benutzereingabe: 123
3 774 + 123 = 897

Das Ergebnis lässt sich natürlich auch in einer Variablen zwischenspeichern. Folgendes Beispiel demonstriert diese Möglichkeit:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     int summand1, summand2, ergebnis;          // Anlegen von drei Variablen
 5 
 6     std::cin >> summand1 >> summand2;          // Zwei Zahlen eingeben
 7 
 8     ergebnis = summand1 + summand2;            // Ergebnis berechnen
 9 
10     std::cout << summand1 << " + " << summand2 // beide durch " + " getrennt wieder ausgeben
11               << " = "                         // " = " ausgeben
12               << ergebnis                      // Ergebnis ausgeben
13               << std::endl;                    // Zeilenumbruch
14 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 Benutzereingabe: 400
2 Benutzereingabe: 300
3 400 + 300 = 700

Die großen Vier[Bearbeiten]

C++ beherrscht die vier Grundrechenarten: Addition (+), Subtraktion (-), Multiplikation (*) und Division (/). Genau wie in der Mathematik gilt auch in C++ die Regel: Punktrechnung geht vor Strichrechnung und Klammern gehen über alles. Das folgende Beispiel soll eine komplexere Rechnung demonstrieren:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     int ergebnis;                                       // Anlegen einer Variable
 5 
 6     ergebnis = ((3 + 3*4)/5 - 1)*512 - 768;             // Ergebnis berechnen
 7 
 8     std::cout << "((3 + 3*4)/5 - 1)*512 - 768 = "       // Aufgabe ausgeben
 9               << ergebnis                               // Ergebnis ausgeben
10               << std::endl;                             // Zeilenumbruch
11 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 ((3 + 3*4)/5 - 1)*512 - 768 = 256

Gerechnet wird in dieser Reihenfolge:

   3 *   4 =   12
   3 +  12 =   15
  15 /   5 =    3
   3 -   1 =    2
   2 * 512 = 1024
1024 - 768 =  256

Sie sollten darauf achten, immer die gleiche Anzahl öffnende und schließende Klammern zu haben, denn dies ist ein beliebter Fehler, der von Anfängern meist nicht so schnell gefunden wird. Compiler bringen in solchen Fällen nicht selten Meldungen, die einige Zeilen unter dem eigentlichen Fehler liegen.

Zusammengesetzte Operatoren[Bearbeiten]

C++ ist eine Sprache für schreibfaule Menschen. Daher gibt es die Möglichkeit, die Rechenoperatoren mit dem Zuweisungsoperator zu kombinieren. Dies sieht dann folgendermaßen aus:

Nuvola-inspired-terminal.svg
1 zahl  = 22;
2 zahl += 5; // zahl = zahl + 5;
3 zahl -= 7; // zahl = zahl - 7;
4 zahl *= 2; // zahl = zahl * 2;
5 zahl /= 4; // zahl = zahl / 4;

Als Kommentar sehen Sie die Langfassung geschrieben. Diese Kurzschreibweise bedeutet nicht mehr, als dass die vor (!) dem Zuweisungsoperator stehende Rechenoperation mit der Variablen auf der linken Seite und dem Wert auf der rechten Seite ausgeführt und das Ergebnis der Variablen auf der linken Seite zugewiesen wird. Sie sollten diese Kurzschreibweise der ausführlichen vorziehen, da sie nicht nur die Finger schont, sondern auch noch ein wenig schneller ist.

Am besten werden Sie dies wahrscheinlich verstehen, wenn Sie es einfach ausprobieren. Stehen auf der rechten Seite noch weitere Rechenoperationen, so werden diese zuerst ausgeführt. Das Ganze stellt sich dann also folgendermaßen dar:

Nuvola-inspired-terminal.svg
1 zahl  = 5;
2 zahl *= 3 + 4; // zahl = zahl * (3 + 4);

Inkrement und Dekrement[Bearbeiten]

Inkrementieren bedeutet, den Wert einer Variablen um 1 zu erhöhen, entsprechend bedeutet Dekrementieren 1 herunterzuzählen. Dem Inkrementoperator schuldet C++ übrigens seinen Namen. Die beiden Operatoren gibt es jeweils in der Präfix- und der Postfix-Variante. Insgesamt ergeben sich also vier Operatoren:

Nuvola-inspired-terminal.svg
1 zahl = 5;
2 
3 zahl++; // Inkrement Postfix (zahl == 6)
4 ++zahl; // Inkrement Präfix  (zahl == 7)
5 zahl--; // Dekrement Postfix (zahl == 6)
6 --zahl; // Dekrement Präfix  (zahl == 5)

Der Unterschied zwischen Inkrement (++) und Dekrement (--) ist ohne größeres Nachdenken erkennbar. Der Sinn von Präfix und Postfix ergibt sich hingegen nicht sofort von selbst. C++ schuldet seinen Namen der Postfix-Variante.

Der Unterschied zwischen Präfix und Postfix besteht im Rückgabewert. Die Präfix-Variante erhöht den Wert einer Zahl um 1 und gibt diesen neuen Wert zurück. Die Postfix-Variante erhöht den Wert der Variablen ebenfalls um 1, gibt jedoch den Wert zurück, den die Variable vor der Erhöhung hatte.

Das folgende kleine Programm zeigt den Unterschied:

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 int main(){
 4     int zahl;                             // Anlegen einer Variable
 5 
 6     std::cout << "zahl direkt ausgeben:\n";
 7 
 8     zahl = 5;                             // zahl den Wert 5 zuweisen
 9 
10     std::cout << zahl << ' ';             // zahl ausgeben
11 
12     zahl++;                               // Inkrement Postfix (zahl == 6)
13     std::cout << zahl << ' ';             // zahl ausgeben
14 
15     ++zahl;                               // Inkrement Präfix  (zahl == 7)
16     std::cout << zahl << ' ';             // zahl ausgeben
17 
18     zahl--;                               // Dekrement Postfix (zahl == 6)
19     std::cout << zahl << ' ';             // zahl ausgeben
20 
21     --zahl;                               // Dekrement Präfix  (zahl == 5)
22     std::cout << zahl << ' ';             // zahl ausgeben
23 
24     std::cout << "\nRückgabewert des Operators ausgeben:\n";
25 
26     zahl = 5;                             // zahl den Wert 5 zuweisen
27 
28     std::cout << zahl   << ' ';           // zahl ausgeben
29     std::cout << zahl++ << ' ';           // Inkrement Postfix (zahl == 6)
30     std::cout << ++zahl << ' ';           // Inkrement Präfix  (zahl == 7)
31     std::cout << zahl-- << ' ';           // Dekrement Postfix (zahl == 6)
32     std::cout << --zahl << ' ';           // Dekrement Präfix  (zahl == 5)
33 
34     std::cout << "\nEndwert von zahl: " << zahl << std::endl;
35 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 zahl direkt ausgeben:
2 5 6 7 6 5
3 Rückgabewert des Operators ausgeben:
4 5 5 7 7 5
5 Endwert von zahl: 5
Symbol move vote.svg
Thema wird später näher erläutert…

In einem späteren Kapitel werden Sie noch ein paar zusätzliche Informationen erhalten, was beim Rechnen schief gehen kann und wie Sie es vermeiden. Wenn Sie beim Herumexperimentieren mit Rechenoperationen plötzlich scheinbar unerklärliche Ergebnisse erhalten, dann ist es an der Zeit einen Blick auf dieses Kapitel zu werfen.

Crystal source cpp.png

Im Anhang zu diesem Kapitel finden Sie:

  • Aufgaben und zugehörige Musterlösungen.
Aufgaben
Symbol neutral vote.svg Aufgabe 1: Rechnen Sie die Ergebnisse der folgenden Aufgaben aus und schreiben Sie ein Programm, welches das Gleiche tut.
zahl  = (500 - 100*(2 + 1))*5
zahl  = (zahl - 700)/3
zahl += 50*2
zahl *= 10 - 8
zahl /= zahl - 200
 
Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2  
 3 int main(){
 4     int zahl;
 5  
 6     zahl  = (500 - 100*(2 + 1))*5;  // 1000
 7     zahl  = (zahl - 700)/3;         //  100
 8     zahl += 50*2;                   //  200
 9     zahl *= 10 - 8;                 //  400
10     zahl /= zahl - 200;             //    2
11     
12     std::cout << "zahl: " << zahl;
13 }
Crystal Clear app kscreensaver.svg
Ausgabe:
1 zahl: 2