Im Grunde ist ein Programm, sei es in C++ geschrieben oder in einer anderen Programmiersprache, nichts anderes als Kommandos, die nacheinander abgearbeitet werden. Diese Kommandos bestehen aus Ausdrücken und Anweisungen und nutzen Operatoren um bestimmte Berechnungen oder andere Aktionen auszuführen.

Anweisungen

Die erste wichtige Anweisung, die wir gelernt haben:

cout << "Hello World!"  << endl;

Eine Anweisung mit cout gibt Text im Terminal auf dem Bildschirm aus. In C++ enden alle Anweisungen mit einem Semikolon (;). Das Semikolon markiert die Grenze oder das Ende einer Anweisung, vergleichbar mit dem Punkt (.) in der deutschen Sprache. Die nächste Anweisung könnte direkt hinter dem Semikolon beginnen, aber aus Gründen der Übersichtlichkeit ist es ratsamer eine neue Anweisung auch in einer neuen Zeile zu beginnen.

Whitespaces (Leerzeichen, Tabs, Zeilenumbrüche, usw,) sind für den Compiler nicht sichtbar. Whitespaces in String Literalen allerdings schon. Die folgende Anweisung würde einen Fehler verursachen:

cout << "Hello
         World" << endl;  // new line in string literal is not allowed

An dieser Stelle wird der Compiler sicher meckern, dass ein schließendes Anführungszeichen („) und ein Semikolon am Ende der Zeile fehlt. Falls man ein String Literal über mehrere Zeilen erstrecken muss, dann sollte man entweder ein Backslash (\) benutzen …

cout << "Hello \
         World!" << endl;  // split to two lines is OK

… oder das String Literal in zwei aufteilen:

cout << "Hello "
        "World!" << endl;  // two string literals is also OK

Zusammengesetzte Anweisungen oder Blöcke

Wenn man mehrere Anweisungen zusammen zwischen zwei geschweifte Klammern packt {…}, dann hat man zusammengesetzte Anweisungen, oder einfach einen Block.

{
    int myAge = 46;
    cout << "This block holds an int and a cout statement.";
}

Ein Block enthält mehrere Anweisungen und zeigt, dass diese zusammen gehören. Blöcke sind besonders bei if … Anweisungen oder Schleifen sinnvoll, dazu aber später mehr…

Operatoren

Operatoren sind C++ Werkzeuge, die es einem ermöglichen mit Daten zu arbeiten, sie zu verändern, und Entscheidungen auf der Basis von Daten zu treffen.

Der Zuweisungsoperator (=)

Den Zuweisungsoperator haben wir schon ganz intuitiv genutzt.

int myAge = 46;

Diese Anweisung benutzt den Zuweisungsoperator, um die Integer Variable myAge mit 46 zu initialisieren. Der Zuweisungsoperator ersetzt den Wert des Operanden auf der linken Seite (L-Value) mit dem Wert des Operators auf der rechten Seite (R-Value).

L-Values und R-Values

L-Values beziehen sich meistens auf Speicherplätze. Eine Variable wie myAge ist ein Name für einen bestimmten Speicherbereich und ist ein L-Value. R-Values wiederum sind in den meisten Fällen der Inhalt solcher Speicherbereiche. Aus diesem Grund könne alle L-Values auch R-Values sein, aber nicht alle R-Values können L-Values sein! Das folgende Beispiel lässt sich nicht kompilieren:

46 = myAge;   // makes no sense...

Operatoren zur Addition (+), Subtraktion (-), Multiplikation (*), Division (/) und Rest-Division (%)

Man kann arithmetische Operationen mit zwei Operanden mithilfe eines + (für Addition), – (für Subtraktion), * (für Multiplikation), / (für Division) und & (für die Rest-Division) durchführen:

int num1 = 22;
int num2 = 5;
int addNums = num1 + num2;  // 27
int subtractNums = num1 - num2;  // 17
int multiplyNums = num1 * num2;  // 110
int divideNums = num1 / num2;  // 4
int moduloNums = num1 % num2;  // 2

Man beachte, dass die Division (/) in diesem Fall eine 4 zurückgibt. Das liegt daran, dass wir einen Integer verwendet haben und Integer haben keine Dezimalstellen. Der Modulo-Operator (Rest-Division) gibt den Rest einer Division zurück.

Operatoren zum Inkrementieren (++) und Dekrementieren (- -)

Manchmal muss man in Einer-Schritten zählen. Das kommt z.B. sehr oft in Schleifen vor, wo der Wert einer Variablen nach jedem Schleifendurchlauf inkrementiert oder dekrementiert werden muss. C++ beinhaltet den ++ (Inkrementieren) und -- (Dekrementieren) Operator, um diese Aufgaben etwas einfacher zu machen.

int num1 = 101;
int num2 = num1++; // Postfix increment operator
int num2 = ++num1;  // Prefix increment operator
int num2 = num1--;  // Postfix decrement operator
int num2 = --num1;  // Prefix decrement operator

Wie man sehen kann, gibt es jeweils zwei verschiedene Operatoren zum Inkrementieren und Dekrementieren, einmal davor und einmal danach. Es ist wichtig, dass man den Unterschied zwischen Prefix– und Postfix-Operatoren kennt.

Das Ergebnis eines Postfix-Operators ist, dass dem L-Value erst der Wert des R-Values übergeben wird und erst danach der Wert des R-Values inkrementiert (oder dekrementiert) wird. Das heißt, dass in allen Fällen, wo ein Postfix-Operator benutzt wurde, der Wert von num2 dem alten Wert von num1 entspricht (der Wert bevor der Inkrement- bzw Dekrement-Operator angewandt wurde).

Prefix-Operatoren verhalten sich genau umgekehrt. Der R-Value wird zuerst inkrementiert oder dekrementiert und dann dem L-Value zugewiesen.

// postfixPrefix.cpp

#include <iostream>

using namespace std;

int main() {
    
    int startValue = 101;
    cout << "Start value of integer being operated: " 
         << startValue << endl;
    
    int postfixIncrement = startValue++;
    cout << "Result of Postfix Increment = " 
         << postfixIncrement << endl;
    cout << "After Postfix Increment, startValue = " 
         << startValue << endl;
    
    startValue = 101; // Reset
    int prefixIncrement = ++startValue;
    cout << "Result of Prefix Increment = "
         << prefixIncrement << endl;
    cout << "After Prefix Increment, startValue = " 
         << startValue << endl;

    startValue = 101; // Reset
    int postfixDecrement = startValue--;
    cout << "Result after Postfix Decrement = "
         << postfixDecrement << endl;
    cout << "After Postfix Decrement, startValue = " 
         << startValue << endl;

    startValue = 101; // Reset
    int prefixDecrement = --startValue;
    cout << "Result of Prefix Decrement = " 
         << prefixDecrement << endl;
    cout << "After Prefix Decrement, startValue = "
         << startValue << endl;
    
    return 0;
}

Vergleichsoperatoren (==) und (!=)

Oft muss man überprüfen, ob bestimmte Bedingungen erfüllt oder nicht erfüllt sind, bevor man weitere Aktionen tätigt. Die Vergleichsoperatoren == (Operanden sind gleich) und != (Operanden sind ungleich) machen genau das. Da Ergebnis eines solchen Vergleichs ist ein Boolescher Wert bool – also entweder true oder false.

int myAge = 46;
bool checkEquality = (myAge == 46);  // true
bool checkInequality = (myAge != 100);  // true
bool checkEqualityAgain = (myAge == 200);  // false
bool checkEqualityAgain = (myAge != 20);  // false

Weitere Vergleichsoperatoren

  • Kleiner als (<) – Wird true, wenn der Operand kleiner ist als der andere (op1 < op2), ansonsten ist das Ergebnis false
  • Größer als (>) – Wird true, wenn der Operand größer ist als der andere (op1 > op2), ansonsten ist das Ergebnis false
  • Kleiner oder gleich (<=) – Wird true, wenn der Operand kleiner oder gleich dem anderen ist (op1 <= op2), ansonsten ist das Ergebnis false
  • Größer oder gleich (>=) – Wird true, wenn der Operand größer oder gleich ist (op1 >= op2), ansonsten ist das Ergebnis false

Logische Operatoren NOT, AND, OR und XOR

Der logische NOT-Operator wird durch das ! dargestellt und wird immer nur auf einen einzelnen Operanden angewendet:

FALSE == !TRUE
TRUE == !FALSE

Die anderen Operatoren wie AND, OR und XOR benötigen zwei Operanden. Das AND wird nur true, wenn beiden Operanden true sind. Der Operator AND wird in C++ mit && dargestellt

Das logische OR wird nur true, wenn wenigstens ein Operand true ist. In C++ wir OR mit dem || dargestellt.

Das exklusive OR (XOR) ist etwas anders als das OR, es wird nur true, wenn höchstens ein Operand true ist, aber nicht beide.

// logicalOperators.cpp

#include <iostream>

using namespace std;

int main() {

    cout << "Enter true(1) or false(0) for two operands:" << endl;
    bool op1 = false;
    bool op2 = false;

    cin >> op1;
    cin >> op2;

    cout << op1 << " AND " << op2 << " = " << (op1 && op2) << endl;
    cout << op1 << " OR "  << op2 << " = " << (op1 || op2) << endl;
    cout << "!" << op1 << " = " << (!op1) << endl;
    cout << "!" << op2 << " = " << (!op2) << endl;

    return 0;
}
Enter true(1) or false(0) for two operands:
1
0
1 AND 0 = 0
1 OR 0 = 1
!1 = 0
!0 = 1

In diesem Artikel ging es um die grundlegenden Anweisungen, Ausdrücke und Operatoren in C++. Ich habe gezeigt, wie man arithmetische Operationen durchführt, wie Addition, Multiplikation, Subtraktion, Division und Rest-Division. Außerdem habe ich einen Überblick über die logischen Operatoren gegeben.

Im nächsten Teil geht es dann um die Kontrolle des Programmablaufs…