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

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

#include <iostream>

int main(){
    std::cout << "7 + 8 = " << 7 + 8 << std::endl; // Ausgabe einer Rechnung
}

Ausgabe:

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:

#include <iostream>

int main(){
    int summand1, summand2;                    // Anlegen von zwei Variablen

    std::cin >> summand1 >> summand2;          // Zwei Zahlen eingeben

    std::cout << summand1 << " + " << summand2 // beide durch " + " getrennt wieder ausgeben
              << " = "                         // " = " ausgeben
              << summand1 + summand2           // Ergebnis berechnen und ausgeben
              << std::endl;                    // Zeilenumbruch
}

Ausgabe:

Benutzereingabe: 774
Benutzereingabe: 123
774 + 123 = 897

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

#include <iostream>

int main(){
    int summand1, summand2, ergebnis;          // Anlegen von drei Variablen

    std::cin >> summand1 >> summand2;          // Zwei Zahlen eingeben

    ergebnis = summand1 + summand2;            // Ergebnis berechnen

    std::cout << summand1 << " + " << summand2 // beide durch " + " getrennt wieder ausgeben
              << " = "                         // " = " ausgeben
              << ergebnis                      // Ergebnis ausgeben
              << std::endl;                    // Zeilenumbruch
}

Ausgabe:

Benutzereingabe: 400
Benutzereingabe: 300
400 + 300 = 700

Die großen Vier

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:

#include <iostream>

int main(){
    int ergebnis;                                       // Anlegen einer Variable

    ergebnis = ((3 + 3*4)/5 - 1)*512 - 768;             // Ergebnis berechnen

    std::cout << "((3 + 3*4)/5 - 1)*512 - 768 = "       // Aufgabe ausgeben
              << ergebnis                               // Ergebnis ausgeben
              << std::endl;                             // Zeilenumbruch
}

Ausgabe:

((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

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:

zahl  = 22;
zahl += 5; // zahl = zahl + 5;
zahl -= 7; // zahl = zahl - 7;
zahl *= 2; // zahl = zahl * 2;
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:

zahl  = 5;
zahl *= 3 + 4; // zahl = zahl * (3 + 4);

Inkrement und Dekrement

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:

zahl = 5;

zahl++; // Inkrement Postfix (zahl == 6)
++zahl; // Inkrement Präfix  (zahl == 7)
zahl--; // Dekrement Postfix (zahl == 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:

#include <iostream>

int main(){
    int zahl;                             // Anlegen einer Variable

    std::cout << "zahl direkt ausgeben:\n";

    zahl = 5;                             // zahl den Wert 5 zuweisen

    std::cout << zahl << ' ';             // zahl ausgeben

    zahl++;                               // Inkrement Postfix (zahl == 6)
    std::cout << zahl << ' ';             // zahl ausgeben

    ++zahl;                               // Inkrement Präfix  (zahl == 7)
    std::cout << zahl << ' ';             // zahl ausgeben

    zahl--;                               // Dekrement Postfix (zahl == 6)
    std::cout << zahl << ' ';             // zahl ausgeben

    --zahl;                               // Dekrement Präfix  (zahl == 5)
    std::cout << zahl << ' ';             // zahl ausgeben

    std::cout << "\nRückgabewert des Operators ausgeben:\n";

    zahl = 5;                             // zahl den Wert 5 zuweisen

    std::cout << zahl   << ' ';           // zahl ausgeben
    std::cout << zahl++ << ' ';           // Inkrement Postfix (zahl == 6)
    std::cout << ++zahl << ' ';           // Inkrement Präfix  (zahl == 7)
    std::cout << zahl-- << ' ';           // Dekrement Postfix (zahl == 6)
    std::cout << --zahl << ' ';           // Dekrement Präfix  (zahl == 5)

    std::cout << "\nEndwert von zahl: " << zahl << std::endl;
}

Ausgabe:

zahl direkt ausgeben:
5 6 7 6 5
Rückgabewert des Operators ausgeben:
5 5 7 7 5
Endwert von zahl: 5

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.

Im Anhang zu diesem Kapitel finden Sie:

• Aufgaben und zugehörige Musterlösungen.

Aufgaben

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

 

#include <iostream>
 
int main(){
    int zahl;
 
    zahl  = (500 - 100*(2 + 1))*5;  // 1000
    zahl  = (zahl - 700)/3;         //  100
    zahl += 50*2;                   //  200
    zahl *= 10 - 8;                 //  400
    zahl /= zahl - 200;             //    2
    
    std::cout << "zahl: " << zahl;
}

Ausgabe:

zahl: 2