Was sind Operatoren?
Operatoren sind Zeichen, die dem Computer sagen, wie er ein oder zwei Variablen miteinander verknüpfen soll. Es gibt Operanten zur Berechnung, Zuweisung und für Bit-Operationen.
Rechen-Operatoren
Bei den Rechenoperatoren gibt es Operatoren für die 4 Grund- Rechenarten sowie einen zur Restwertbestimmung.
Nutzt man diese Operatoren bei Integer-Variablen, so werden reine Integerberechnungen durchgeführt, was einen Einfluss auf die Division hat. So ergibt die Berechnung 5 dividiert durch 2 nicht 2,5 sondern lediglich 2.
Bei float/double-Variablen erhält man dagegen den Wert 2,5.
Der Restwert-Operator bestimmt immer den Rest einer Integer-Division, also 5 dividiert durch 2 ergibt den Rest 1, da die 2 zweimal ganz in die 5 passt und somit ein Rest von 1 übrig bleibt.
Addition der Inhalte von Variablen
a + b;
Beispiel:
Ausgabe:
| Das Ergebnis lautet: 300 |
Subtraktion der Inhalte von Variablen
a - b;
Beispiel:
/* Programmkopf*/
void main()
{
int zahl1 = 100, zahl2 = 200, zahl3;
zahl3 = zahl1 - zahl2; // Die Inhalte von Variablen "zahl1" und "zahll2" werden
// subtrahiert und in der Variablen "zahl3" gespeichert.
printf("Das Ergebnis lautet: %d", zahl3);
}
Ausgabe:
| Das Ergebnis lautet: -100 |
Multiplikation der Inhalte von Variablen
a * b;
Beispiel:
/* Programmkopf*/
void main()
{
int zahl1 = 100, zahl2 = 200, zahl3;
zahl3 = zahl1 * zahl2; // Die Inhalte von Variablen "zahl1" und "zahll2" werden
// multipliziert und in der Variablen "zahl3" gespeichert.
printf("Das Ergebnis lautet: %d", zahl3);
}
Ausgabe:
| Das Ergebnis lautet: 20000 |
Division der Inhalte von Variablen
a / b;
Beispiel:
/* Programmkopf*/
void main()
{
int zahl1 = 500, zahl2 = 200, zahl3;
zahl3 = zahl1 / zahl2; // Die Inhalte von Variablen "zahl1" und "zahll2" werden
// dividiert und in der Variablen "zahl3" gespeichert.
// ACHTUNG: Bei int-Variablen kommt immer int raus
// (7 / 2 = 3)
printf("Das Ergebnis lautet: %d", zahl3);
}
Ausgabe:
| Das Ergebnis lautet: 2 |
Restwertbestimmung
a % b;
Beispiel:
/* Programmkopf*/
void main()
{
int zahl1 = 500, zahl2 = 200, zahl3;
zahl3 = zahl1 % zahl2; // Die Inhalte von Variablen "zahl1" und "zahll2" werden
// dividiert und der Rest der Divisionwird in "zahl3"
// gespeichert.
// (7 / 2 = 3 Rest 1; die 1 wird in zahl3 gespeichert)
printf("Das Ergebnis lautet: %d", zahl3);
}
Ausgabe:
| Das Ergebnis lautet: 1 |
Zuweisung und Zuweisung mit gleichzeitiger Berechnung
Bei diesem Typ von Operatoren gelten die gleichen Regeln wie sie auch bei den einfachen Rechen-Operatoren gelten. Allerdings werden die Inhalte zugleich in a geschrieben.
Einfache Zuweisung
a = b
Beispiel:
/* Programmkopf*/
void main()
{
int zahl1;
zahl1 = 100; // Der Variablen "zahl1" wird der Wert 100 zugewiesen.
printf("Der Inhalt der Variablen \"zahl1\" lautet: %d", zahl1);
}
Ausgabe:
| Der Inhalt der Variablen "zahl1" lautet: 100 |
Zuweisung und Addition
a += b;
Beispiel:
/* Programmkopf*/
void main()
{
int zahl1 = 100, zahl2 = 200 ;
zahl1 += zahl2; // gleichbedeutend mit zahl1 = zahl1 + zahl2; Die Inhalte von
// "zahl1" und "zahl2" werden addiert. Das Ergebnis überschreibt
// den Inhalt der Variablen "zahl1"
printf("Der Inhalt der Variablen \"zahl1\" lautet: %d", zahl1);
}
Ausgabe:
| Der Inhalt der Variablen "zahl1" lautet: 300 |
Zuweisung und Subtraktion
a -= b;
Beispiel:
/* Programmkopf*/
void main()
{
int zahl1 = 100, zahl2 = 200 ;
zahl1 -= zahl2; // gleichbedeutend mit zahl1 = zahl1 - zahl2; Die Inhalte von
// "zahl1" und "zahl2" werden subtrahiert; Das Ergebnis überschreibt
// den Inhalt der Variablen "zahl1"
printf("Der Inhalt der Variablen \"zahl1\" lautet: %d", zahl1);
}
Ausgabe:
| Der Inhalt der Variablen "zahl1" lautet: -100 |
Zuweisung und Multiplikation
a *= b;
Beispiel:
/* Programmkopf*/
void main()
{
int zahl1 = 100, zahl2 = 200 ;
zahl1 *= zahl2 // gleichbedeutend mit zahl1 = zahl1 * zahl2; Die Inhalte von
// "zahl1" und "zahl2" werden multipliziert; Das Ergebnis überschreibt
// den Inhalt der Variablen "zahl1"
printf("Der Inhalt der Variablen \"zahl1\" lautet: %d", zahl1);
}
Ausgabe:
| Der Inhalt der Variablen "zahl1" lautet: 20000 |
Zuweisung und Division
a /= b;
Beispiel:
/* Programmkopf*/
void main()
{
int zahl1 = 500, zahl2 = 200 ;
zahl1 /= zahl2; // gleichbedeutend mit zahl1 = zahl1 / zahl2; Die Inhalte von
// "zahl1" und "zahl2" werden dividiert; Das Ergebnis überschreibt
// den Inhalt der Variablen "zahl1"
// ACHTUNG: Bei int-Variablen kommt immer int raus
// (7 / 2 = 3)
printf("Der Inhalt der Variablen \"zahl1\" lautet: %d", zahl1);
}
Ausgabe:
| Der Inhalt der Variablen "zahl1" lautet: 2 |
Zuweisung und Restwertbestimmung
a %= b; // a = a % b; Inhalt von a und b werden dividiert, der Rest überschreibt a.
Beispiel:
/* Programmkopf*/
void main()
{
int zahl1 = 500, zahl2 = 200 ;
zahl1 %= zahl2; // gleichbedeutend mit zahl1 = zahl1 % zahl2; Die Inhalte von
// "zahl1" und "zahl2" werden dividiert; Der Rest der Division
// überschreibt den Inhalt der Variablen zahl1
// (7 / 2 = 3 Rest 1; die 1 wird in "zahl1" gespeichert)
printf("Der Inhalt der Variablen \"zahl1\" lautet: %d", zahl1);
}
Ausgabe:
| Der Inhalt der Variablen "zahl1" lautet: 100 |
Inkrement- und Dekrement-Operatoren
Mit diesen Operatoren wird der Wert der angegebenen Variable um 1 erhöht oder verringert.
Postfix
Bei der Postfix-Variante werden die Inhalte zuerst genutzt und dann geändert.
a++;
a--;
Beispiel:
/* Programmkopf*/
void main()
{
int zahl1 = 100;
printf("Erstes mal Zahl1.: %d\n", zahl1++ ); // Ausgabe der Variablen und
// anschließende Erhöhung um 1
printf("Zweites mal Zahl1: %d\n", zahl1 ); // Ausgabe der Variablen
}
Ausgabe:
| Erstes mal Zahl1..: 100 Zweites mal Zahl1: 101 |
Präfix
Bei der Präfix-Variante werden die Inhalte zuerst geändert und dann genutzt.
++a;
--a;
Beispiel:
/* Programmkopf*/
void main()
{
int zahl1 = 100;
printf("Erstes mal Zahl1...: %d\n", --zahl1 ); // Erst Verminderung um 1 und dann
// anschließende Ausgabe der Variablen
printf("Zweites mal Zahl1: %d\n", zahl1 ); // Ausgabe der Variablen
}
Ausgabe:
| Erstes mal Zahl1..: 99 Zweites mal Zahl1: 99 |
Vergleichsoperatoren
Die folgenden 4 Operatoren haben den gleichen Nutzen, wie sie ihn auch in der Mathematik haben:
a < b; // a kleiner b
// liefert ein wahr, wenn a kleiner als b ist
// liefert ein falsch, wenn a größer oder gleich b
a <= b; // a kleiner gleich b
// liefert ein wahr, wenn a kleiner oder gleich b ist
// liefert ein falsch, wenn a größer als b ist
a > b; // a größer b
// liefert ein wahr, wenn a größer als b ist
// liefert ein falsch, wenn a kleiner oder gleich b
a >= b; // a größer gleich b
// liefert ein wahr, wenn a größer oder gleich b ist
// liefert ein falsch, wenn a kleiner als b ist
Dieser Operator vergleicht eine Variable mit einer anderen auf Gleichheit. Nicht verwechseln mit dem einfachen Istgleich-Zeichen!
a == b; // a gleich b
// liefert ein wahr, wenn a gleich b ist
// liefert ein falsch, wenn a ungleich b ist
Folgender Operator entspricht dem Ungleichheitszeichen der Mathematik:
a != b; // a ungleich b
// liefert ein wahr, wenn a ungleich b ist
// liefert ein falsch, wenn a gleich b ist
Logische Operatoren
Negiert (Umkehren) den Wert von a:
!a; // negiert die Aussage
Verknüpft a logisch UND mit b:
a && b; // liefert nur ein wahr,
// wenn sowohl Teil a allein wahr ist UND Teil b allein wahr ist
Verknüpft a logisch ODER mit b:
a || b; // liefert ein wahr,
// sobald Teil a allein wahr ist ODER Teil b allein wahr ist ODER beide
// Teile
Bit-Operatoren
Diese beiden Operatoren sind den beiden aus den logischen Operatoren sehr ähnlich. Allerdings vergleichen sie nicht die gesamten Werte der beiden Variablen als jeweils Ganzes sondern jedes einzelne Bit.
Man legt quasi entweder eine "Und"-Maske in Form von b über a oder eine "Oder"-Maske in Form von b über a:
a & b;
a | b;
Folgende beiden Operatoren verschieben die Bits von a nach links (<<) bzw. nach rechts (>>) um b Stellen. Die dazukommenden Stellen werden mit Nullen (0) aufgefüllt:
a << b;
a >> b;
