Anfang   zurück   weiter

4. Operatoren

Operatoren weisen C an, eine Aktion auf einen oder mehrere Operanden auszuführen.

Mathematische Operatoren

Neben den binären mathematischen Operatoren wie Addition (+), Subtraktion (-), Multiplikation (*), Division (/) und Modulus (%), gibt es die vereinfachte Inkrement und Dekrementanweisung, die den Wert einer Variablen um eins erhöht oder um eins erniedrigt:
++x, x++ für das Inkrement und
--x, x-- für das Dekrement.
Diese Operatoren können nicht auf Konstanten sondern nur auf Variablen angewendet werden. Das heißt die Anweisungen
++x;
--y;
sind äquvalent zu:
x = x + 1;
y = y - 1;
Zu beachten ist, daß die Operatoren vor (prefix mode) oder auch nach (postfix mode) dem Operanden vorkommen können. Den Unterschied in der Wirkung zeigt folgendes Beispiel:
Mit den Anweisungen
x = 10;
y = x++;
hat letztendlich x den Wert 11 und y den Wert 10, während folgende Codezeilen
x = 10;
y = ++x;
am Ende sowohl für x als auch für y den Wert 11 als Ergebnis liefern.

Zuweisungsoperatoren

Als Zuweisungsoperator dient das Gleichheitszeichen (=). Es bedeutet in der Form
variable = expression;
daß der Ausdruck
expression
berechnet und das Ergebnis in der Variablen
variable
abgelegt wird.

Neben dem einfachen Zuweisungsoperator existieren noch sogenannte "compound assignment operators", die eine Kurzmethode für die Kombination von binären mathematischen Zuweisungen anbieten. Sind expr1 und expr2 Ausdrücke, dann ist

expr1 op= expr2
äquvalent zu
expr1 = ( expr1 ) op ( expr2 )
Es ist mit allen fünf binären mathematischen Operatoren möglich, kombinierte Zuweisungen zu erstellen. Beispiele sind in der nachfolgenden Tabelle gegeben:

Die Anweisungen     sind äquvalent zu
x *= y x = x * y
y -= z + 1 y = y - (z + 1)
a /= b a = a / b
y %= 3 y = y % 3
Man sollte dabei auf die Klammerung um expr2 achten!

Vergleichsoperatoren

In "Entscheidungsfragen" wie, ist x grösser als 100, oder ist y gleich 0, kommen C's Vergleichsoperatoren zum Einsatz. Ein Ausdruck der einen Vergleichsoperator enthält, erhält als Ergebnis den Wert 1 für wahr und 0 für falsch (eigentlich wird in C jeder Ausdruck dessen Wert ungleich Null ist als wahr gewertet, und jeder Ausdruck dessen Wert gleich Null ist als falsch). Die Vergleichsoperatoren sind:

Operator Symbol     Beispiel
gleich = = x = = y
nicht gleich != x != 1
grösser > y > 1
grösser gleich >= x >= 0
kleiner < x < y
kleiner gleich <= z <= x
Man verwechsle nicht die Zuweisung (einfaches =) mit der Abfrage auf Gleichheit ( = = ). Dieser Fehler kann sehr leicht übersehen werden und führt in der Folge zu logischen Programmfehlern. Die Abfrage ob der Wert einer Variablen gleich einer bestimmten Grösse ist, würde z.B. lauten
if (x == 5)
   printf("Der Wert der Variablen x ist gleich 5");
else
   printf("Der Wert der Variablen x ist ungleich 5");

Das Programm würde also abhängig vom Inhalt der Variablen x entweder die eine oder die andere Meldung ausgeben. Lauten die Programmzeilen aber:

if (x = 5)
   printf("Der Wert der Variablen x ist gleich 5");
else
   printf("Der Wert der Variablen x ist ungleich 5");
wird der else Teil des if statements nie ausgeführt. Es passiert nämlich folgendes:

Der Variablen x wird der Wert 5 zugewiesen, dieser Wert wird auch für die Bewertung der if Abfrage herangezogen, und da er ungleich Null ist als wahr interpretiert! Das heißt eine Abfrage ob der Inhalt einer Variable ungleich Null ist
if (x != 0)
kann auch einfach mit
if (x)
durchgeführt werden.

Logische Operatoren

Mittels der logischen Operatoren ist es möglich zwei oder mehrere Vergleichsoperationen auf einmal durchzuführen und als Ergebnis entweder den Wert für wahr oder für falsch zu erhalten.

C's logische Operatoren sind:
Operator Symbol Beispiel
und && expr1 && expr2
oder || expr1 || expr2
nicht ! !expr

Als Beispiel sei die Abfrage ob der Wert einer Variablen größer als eins und kleiner als fünf ist angeführt:

if (x > 1) && (x < 5)

Bitweise Operatoren

Im Unterschied zu den logischen Operatoren können mit den bitweisen Operatoren einzelne Bits beeinflusst werden. Dabei wird eine Bytevariable mittels dieser Bitoperationen mit einem anderen Bitmuster (der Maske) verknüpft. Beim Bitkomplement werden in der Bytevariablen alle Bits die auf 1 stehen zu 0 und alle Bits mit 0 auf 1 gesetzt.

Die Bit-Operatoren sind:
Operator Symbol
Bitkomplement ~
Bit-Und &
Bit-Oder |
Bit-Exclusiv-Oder ^
Im folgenden Beispiel wird ein Vergleich der logischen und bitweisen Verknüpfungen gegeben:
#include <stdio.h>

int main(void)
{
unsigned char byte1 = 0xFF,	/* Alle Bits gesetzt    */
              byte2 = 0xF0;	/* Erste 4 Bits gesetzt */
unsigned char bitresult,
              logresult;

bitresult = ~byte1;
logresult = !byte1;
printf("Negation von 0xFF : Bit = %2.2X logisch = %2.2X\n", bitresult, logresult);

bitresult = ~byte2;
logresult = !byte2;
printf("Negation von 0xF0 : Bit = %2.2X logisch = %2.2X\n", bitresult, logresult);

bitresult =  byte1 & byte2;
logresult = byte1 && byte2;
printf("UND zw. 0xFF und 0xF0 : Bit = %2.2X logisch = %2.2X\n", bitresult, logresult);

bitresult =  byte1 | byte2;
logresult = byte1 || byte2;
printf("ODER zw. 0xFF und 0xF0 : Bit = %2.2X logisch = %2.2X\n", bitresult, logresult);
return 0;
}

Bedingter Ausdruck (conditional operator)

Die Anweisungen
if (a > b)
   z = a;
else
   z = b;
können kompakt mit dem Operatorpaar "? :" formuliert werden. Im Ausdruck
expr1 ? expr2 : expr3
wird zunächst expr1 berechnet. Ist der Wert nicht Null, trifft also die Bedingung zu, dann wird der Ausdruck expr2 bestimmt und dessen Ergebnis ist das Resultat des bedingten Ausdruckes, sonst wird expr3 berechnet und das ist das Resultat. Das obige Beispiel in dem das Maximum von a und b an z zugewiesen wurde, stellt sich also so dar:
z = (a > b) ? a : b;

Komma Operator

Ein letzter C-Operator ist das Komma. Zwei Ausdrücke, die durch ein Komma getrennt sind, werden von links nach rechts bewertet; Datentyp und Resultatwert sind dann der Typ und Wert des rechten Operanden.
x = (y = 3, y + 2);
weist an y den Wert 3 und x den Wert fünf zu. Die Klammerung im obigen Ausdruck ist notwendig, da der Komma Operator eine niedrigere Priorität als die Zuweisung aufweist.

Der sizeof()-Operator

Die Frage wieviel Speicherplatz ein Datentyp nun aktuell benötigt, kann mit dem sizeof()-Operator beantwortet werden. Auch wenn es so aussieht, als handle es sich um eine Funktion, so ist sizeof doch ein Operator. Der Rückgabewert des Operators ist die Datentypgröße in Bytes. Das folgende Programm gibt den Speicherverbrauch einiger Variablentypen an.
#include <stdio.h>
int main(void)
{
   printf("Datentyp-Größen\n\n");
   printf("char: %d\n", sizeof(char));
   printf("int: %d\n", sizeof(int));
   printf("short int: %d\n", sizeof(short int));
   printf("long int: %d\n", sizeof(long int));
   printf("float: %d\n", sizeof(float));
   printf("double: %d\n", sizeof(double));
   return 0;
}

Vorrang und Assoziativität aller Operatoren

Abschließend werden in der folgenden Tabelle die Regeln über den Vorrang und die Assoziativität aller Operatoren zusammengefasst. Innerhalb einer Zeile haben Operatoren den gleichen Vorrang, die Zeilen sind mit abnehmendem Vorrang angeordnet.

Operatoren  Assoziativität 
  ()  []  ->  .   von links her
  !  ~  ++  --   +  -  *  &   von rechts her
  *  /  %   von links her
  +  -   von links her
  <<  >>   von links her
  <  <=  >  > =   von links her
  = =  !=   von links her
  &   von links her
  ^   von links her
  |   von links her
  &&   von links her
  ||   von links her
  ?:   von rechts her
  =  +=  -=  *=   /=  %=  &=  ^=  |=   <<=  >>=   von rechts her
  ,   von links her

Unär haben +, - und * mehr Vorrang als binär.


Und als nächstes die Kontrollstrukturen (Abfragen, Schleifen).