Ausdrücke und Operatoren
Eine wichtige Fähigkeit von Programmiersprachen ist die Auswertung beziehungsweise die Berechnung von Ausdrücken.
Ein Ausdruck kann aus mehrere verschiedene Operanden wie Variablen, Konstanten oder Rückgabewerten von Funktionen bestehen. An jeder Stelle, wo ein Wert erwartet wird, kann eine komplexe Berechnung stehen, die zuerst ausgewertet wird und dann einen Wert ergibt. Vorausgesetzt ist das der Ausdruck einen passenden Datentyp besitzt.
Die einfachsten Bestandteile von Ausdrücke sind Literale. Dabei handelt es sich um Werte, die nicht weiter berechnet werden müssen.
Integerliterale
Integerliterale werden für die Darstellung von Ganzzahlen verwendet. Diese Werte können als Dezimalwert, Oktalwert (mit vorangestellter 0) oder als Hexadezimalwert (mit vorangestellter 0x) geschrieben werden.
251 // Dezimalzahl, Wert = 251
033 // Oktalzahl, Wert = 41
0x59 // Hexadezimalzahl, Wert = 3B
Fließkommaliterale
Fließkommaliterale werden für die Darstellung von Fließkommazahlen verwendet.
Achtung!
Es ist zwingend zu beachten, dass das Komma nicht als Dezimaltrennzeichen verwendet werden darf.
Um Dezimalzahlen in der Programmierung zu trennen, wird der Punkt verwendet. Das Komma wird in der Programmierung für Aufzählungen verwendet.
13.54
Zeichenliterale
Zeichenliterale sind einzelne Zeichen, mit denen der Compiler umgehen kann, wenn sie in einfachen Anführungszeichen stehen.
"a"
Stringliterale
Stringliterale sind Zeichenketten, die gesamte Textblöcke umfassen können, sie stehen immer in doppelten Anführungszeichen. Eine Ausnahme bildet das Leerzeichen, dieses wird durch zwei unmittelbar aufeinanderfolgende doppelte Anführungszeichen abgebildet.
"Zeichenkette mit beliebig viele Zeichen."
"" // Leerzeichen
Zuweisungen
Andere Bestandteile von Ausdrücken sind Variablen. Die Auswertung des Ausdrucks wird der jeweiligen Variablen zugewiesen. Die Zuweisung erfolgt durch den Zuweisungsoperator (=).
a = 3;
b = a + 2; // b hat den Wert 5
Der Zuweisungsoperator wird dazu verwendet, der Variable den Wert des Ausdrucks zuzuweisen. Der Zuweisungsoperator steht zwischen der Variable und dem Ausdruck.
a = 4;
Achtung!
Verwechslungsgefahr!
Der Zuweisungsoperator (Einfaches =) wird für die Zuweisung von Variablen verwendet. Der Vergleichsoperator (Doppeltes ==) wird für den Vergleich von Ausdrücken verwendet.
Neben den Elementen, die einen einzelnen Wert ergeben, können Ausdrücke auch andere Operatoren beinhalten. Die Operatoren werden in arithmetische-, vergleichs- oder logische Operatoren unterteilt.
Arithmetische Operatoren
Die arithmetischen Operatoren bestehen aus den Grundrechenarten: + (Addition), - (Subtraktion), * (Multiplikation), / (Division) und dem % (Modulo, der Rest einer ganzzahligen Division).
2 + 5; // 7
4 - 3; // 1
4 * 5; // 20
6 / 2; // 3
9 % 5; // 4
Vergleichsoperatoren
Die Vergleichsoperatoren: == (Gleichheit), != (Ungleichheit), < (kleiner als), > (größer als), <= (kleiner oder gleich), >= (größer oder gleich), werden verwendet, um Ausdrücke miteinander zu vergleichen. Sollte der Vergleich falsch sein, wird eine "0" als Ergebnis geliefert, andernfalls wird "1" zurückgeliefert.
4 < 6; // Wahr, Rückgabewert 1
5 < 2; // Falsch, Rückgabewert 0
8 < 8; // Falsch, Rückgabewert 0
8 <= 8; // Wahr, Rückgabewert 1
5 == 5; // Wahr, Rückgabewert 1
5 != 5; // Falsch, Rückgabewert 0
3 < 9; // Wahr, Rückgabewert 1
3 !< 9; // Falsch, Rückgabewert 0
4 > 6; // Falsch, Rückgabewert 0
Anders als in anderen Sprachen gibt in C nicht die booleschen Wahrheitswerte "true" oder "false".
Stattdessen wird mit den Werten "0" für falsch oder "1" für wahr gearbeitet.
Logische Operatoren
Die logischen Operatoren bestehen aus: && (logisches Und), || (logisches Oder), ! (logisches Nicht).
Das logische Und (&&) überprüft zwei Teile eines Ausdrucks, nur wenn beide Teile wahr sind, also nicht den Wert "0" enthalten, dann ist der Gesamtausdruck auch wahr.
(4 < 5) && (2 < 3); // Wahr, Rückgabewert 1
(4 > 5) && (2 < 3); // Falsch, Rückgabewert 0
Das logische Oder (||) überprüft, ob mindestens einer der beiden Ausdrücke wahr ist.
(4 < 2) || (2 < 1); // Falsch, Rückgabewert 0
(4 > 5) || (2 < 3); // Wahr, Rückgabewert 1
Das logische Nicht (!) wird für die Negation verwendet, anders gesagt prüft es die Ungleichheit. Also alles, was wahr ist, kann mit der Negation umgekehrt, also zu einem falschen Wert gemacht werden.
5 == 5; // Wahr, Rückgabewert 1
5 != 5; // Falsch, Rückgabewert 0
Inkrement und Dekrement werden verwendet, um die Schreibweise von Funktionen zu verkürzen. Mit dem Inkrement (++) werden Werte um 1 erhöht und mit dem Dekrement (--) wird der Wert um 1 verringert.
a = 5;
a++; // a hat jetzt den Wert 6
b = 5;
b--; // b hat jetzt den Wert 4
Dieses Vorgehen ist in vielen Schleifen wieder zu finden und eine beliebte Methode, um den Programmablauf zu steuern.
Ein besonderer Operator ist der Fallunterscheidungsoperator (?).
Er wird verwendet, um eine "if-else"-Anweisung in einer verkürzten Schreibform zu erstellen.
Der Fallunterscheidungsoperator ist der einzige Operator, der aus 3 Operanden besteht und wird daher auch als ternärer Operator bezeichnet.
Bei dem Fallunterscheidungsoperator wird zuerst die Bedingung ausgewertet, trifft diese zu, wird der erste Ausdruck abgearbeitet (links vom Doppelpunkt).
Trifft diese nicht zu, wird der zweite Ausdruck abgearbeitet (rechts vom Doppelpunkt).
a = 1;
b = (a == 1 ? 20 : 100); // b bekommt den Wert 20
c = 33;
d = (c == 1 ? 20 : 100) // d bekommt den Wert 100
Für größere Statements wird in der Praxis die Fallunterscheidung durch "if-else"Anweisungen empfohlen, weil diese eine bessere Übersicht liefern.
Weiter mit Arrays und Strukturen