• Einführung in die Programmierung für Studierende der Physik

• von Dr.phil.nat.Dr.rer.pol. Matthias Hanauske

Arithmetik und Operatoren

Im vorigen Unterkapitel (Datentypen und Variablen) haben wir gelernt, wie man eine Variable nach ihrem Datentyp deklariert und mit einem nummerischen Wert initialisiert. Möchte man mit diesen Variablen Berechnungen durchführen, muss man zunächst geeignete Operatoren einführen, die die Variablen miteinander kombinieren (z.B. die Multiplikation zweier Variablen). Man unterscheidet hierbei die arithmetischen Operatoren, die logischen Vergleichsoperatoren und weitere spezifische Operatoren. Die folgende Tabelle listet diese Arten von Operatoren auf und verdeutlicht ihre Bedeutung mittels eines Beispiels.

Die arithmetischen Operatoren sind weitgehend selbsterklärend, wobei der Divisionsrest bei ganzen Zahlen ( x % y : x Modulo y ) nur auf zwei ganze Zahlen angewendet werden darf. Die logischen Vergleichsoperatoren sind ebenfalls weitgehend selbsterklärend und diese werden in der nächsten Vorlesung, im Unterkapitel C++ Anweisungen: Auswahlanweisungen mit if und switch im Detail besprochen. Die in der dritten Tabelle aufgelisteten "Weiteren spezifischen Operatoren" sind allgemein nicht so geläufig, werden jedoch in der Programmierung häufig verwendet. Speziell der Inkrementierungsoperator ++x und Dekrementierungsoperator --x ist wichtig und diese werden in der nächsten Vorlesung, im Unterkapitel C++ Anweisungen: Die while- und for-Schleife häufig verwendet. In dem folgenden Quelltext des C++ Programms "Operatoren.cpp" wird die Verwendung einiger Operatoren (z.B. der Multiplikationsoperator "*", das unitäres Minus "-" (Minus Vorzeichen), der Inkrementierungsoperator "++x" oder der Divisionsrest (Modulo Operator %)) verwendet. Zusätzlich werden die, im vorigen Unterkapitel ( Datentypen und Variablen ) diskutierten Bezeichner const, constexpr und auto benutzt und auf die Verwendung von vordefinierten Funktionen der Standardbibliothek <cmath> eingegangen.

#include <iostream>                                // Ein- und Ausgabebibliothek
#include <cmath>                                   // Bibliothek für mathematisches (Sinus, e-Funktion, ...)

using namespace std;                               // Benutze den Namensraum std

int main(){                                        // Hauptfunktion
    const int ganze_zahl_1 = 1;                    // Deklaration einer konstanten ganzen Zahl und Initialisierung mit 1
    const int ganze_zahl_2 = 3;                    // Deklaration einer konstanten zweiten ganzen Zahl und Initialisierung mit 3
    int i = 4;                                     // Deklaration einer integer Variable und Initialisierung mit 4
    double x, y, z;                                // Deklaration dreier double Variablen
    
    constexpr auto zahl_1 = ganze_zahl_1 * ganze_zahl_2;                 // Deklaration eines konstanten Ausdruckes mittels auto
    constexpr auto zahl_2 = double(ganze_zahl_1) / double(ganze_zahl_2); // Deklaration eines konstanten Ausdruckes mittels auto
    
    ++i;                                           // Inkrementierung: i = i + 1

    x = 5.34 * (-zahl_1);                          // Multiplikationsoperator und unitäres Minus (Minus Vorzeichen)
    y = i * sin(x);                                // Sinusfunktion von <cmath>
    z = 1.1 * pow(10,-ganze_zahl_2);               // Potenzfunktion von <cmath> ( a^b := pow(a,b) )
    
    cout.precision(20);                            // Festlegung der Genauigkeit der cout-Ausgabe
    
    cout << "Die Variable 'zahl_1' hat den Wert " << zahl_1;          // Ausgabe eines Textes im Terminal
    cout << " und für sie wurde ein Speicherplatz von "; 
    cout << sizeof(zahl_1) << " Byte im Hauptspeicher reserviert." << endl;
    
    cout << "Die Variable 'zahl_2' hat den Wert " << zahl_2;
    cout << " und für sie wurde ein Speicherplatz von ";
    cout << sizeof(zahl_2) << " Byte im Hauptspeicher reserviert." << endl;
    
    cout << "i = " << i << endl;
    cout << "x = " << x << endl;
    cout << "y = " << y << endl;
    cout << "z = " << z << endl;
    cout << "5 % 3 = " << i % ganze_zahl_2 << endl; // Divisionsrest (Modulo Operator)
}

Am Anfang der "main()"-Funktion werden zunächst zwei konstante ganzzahlige Variablen deklariert ("ganze_zahl_1" und "ganze_zahl_2"), die weiter unten bei der Definition der constexpr Ausdrücke der Variablen "zahl_1" und "zahl_2" verwendet werden. Durch den Bezeichner auto wird beim Initialisierungsprozess den Typ automatisch festlegt. Der durch den Multiplikationsoperator ( zahl_1 = ganze_zahl_1 * ganze_zahl_2 ) erzeugte Wert ist ebenfalls wieder eine ganze Zahl, sodass der erzeugte Datentyp einer konstanten Integerzahl entspricht. Bei der Verwendung des Divisionsoperators muss man als Programmierer aufpassen, dass eine Typenumwandlung der Integerwerte stattfinden muss, da man sonst keine Gleitkommazahl, sondern eine Integerzahl beim Initialisierungsprozess erzeugen würde. Hier wurde die Typenumwandlung (von int nach double) wie folgt erzeugt "zahl_2 = double(ganze_zahl_1) / double(ganze_zahl_2)"; hierauf wird in einem späteren Unterkapitel genauer eingegangen.
Der Inkrementierungsoperator wird auf die ganze Zahlenvariable "i" angewandt, die zuvor, bei ihrer Deklaration, auf den Wert 4 initialisiert wurde und somit nach der Inkrementierung den Wert 5 besitzt. Eine solche Inkrementierung hätte man z.B. mit der konstanten Variable "ganze_zahl_1" nicht machen können. Den deklarierten double-Variablen x, y und z werden mittels unterschiedlicher Operatoren verschiedene Werte zugewiesen. Hierbei wurden auch einige vordefinierten Funktionen aus der Standardbibliothek <cmath> verwendet (die Sinus- und die Potenzfunktion), die in der zweiten Zeile des Programms eingebunden wurde (näheres siehe Die Standardbibliothek <cmath>). Am Ende des Programms werden einige Größen der definierten Variablen ausgegeben und auch der Modulo Operator "%" direkt bei der Ausgabe verwendet.
Wir kompilieren das Programm und führen es im Terminal aus:

Man erkennt, dass die mittels auto deklarierten konstanten Variablen einen unterschiedlichen Speicherbedarf im Hauptspeicher beanspruchen. Die Variable zahl_1 wurde als int-Typ deklariert und beansprucht 4 Byte, wohingegen die Variable zahl_2 als double-Typ deklariert wurde und 8 Byte beansprucht. Zusätzlich erkennt man, dass die Funktionsweise des Inkrementierungsoperators gut funktioniert hat (i=5) und am Ende stimmt auch der mit dem Modulo Operator % berechnete Wert.
Ein wenig unschön ist allein die Terminal Ausgabe und wir werden nun, im folgenden Unterkapitel, einen weiteren Befehl der formatierten Ausgabe näher kennenlernen (printf(...)) und auch die Benutzereingabe einer Zahl besprechen (siehe Die Ein- und Ausgabe).