Die Programmiersprache C wurde 1971 als Gundlage für das Betriebssystem UNIX in den USA entwickelt (UNIX ist zu über 90% in C geschrieben). 1978 wurde von Brian Kernighan und Dennis Ritchie eine eindeutige Sprachdefinition entwickelt. Mittlerweile ist C von ANSI und ISO standardisiert.

Heute sind C und ihr Nachfolger C++ die dominierenden Programmiersprachen. Sehr viele Anwendungen sind in C geschrieben, was inzwischen auch auf eingebettete Systeme zutrifft, die lange in Assembler programmiert werden mussten, da keine ausreichend leistungsfähigen Compiler zur Verfügung standen.

Leider ist C nicht einfach zu lernen – es wurde weder von noch für Hobby-Programmierer entwickelt – und eignet sich daher nur bedingt für den Einsteiger. Mit etwas Übung und einem optimierenden Compiler kann man damit jedoch sehr effiziente Programme schreiben.

Vom Design her ist C eine Hardware-unabhängig Sprache. Das bedeutet, daß C-Programme mit vertretbarem Aufwand auf ein anderes System portiert werden können. Dazu benötigt man lediglich einen anderen Compiler, und Inline-Assembler-Anweisungen (Assembleranweisungen innerhalb eines C-Programmes) müssen der neuen Hardware (Prozessor) angepasst werden.

Inhaltsverzeichnis

1 Geschichte
2 Aufbau eines C-Programmes
3 Das Hauptprogramm main
4 Blöcke
5 Datentypen
6 Variablen
7 Ausdrücke
8 Kontrollanweisungen
9 Ein- und Ausgabe
- 9.1 Bildschirm-Ausgabe
- 9.2 Tastatur-Eingabe
10 Allgemeines zu Unterprogrammen
11 Standard-Funktionen
12 Kurzreferenz
13 Liste der Schlüsselworte
14 Liste der Operatoren
15 Siehe auch
16 Weblinks

Geschichte

1971: C wird entwickelt
1978: Kernighan und Ritchie definieren die Sprache.
1983: ANSI und ISO standardisieren C.
1992: Bjarne Stroustrup enwickelt die Nachfolgesprache C++.

Aufbau eines C-Programmes

Ein einfaches C-Programm könnte folgendermassen aussehen. Das Programm tut eigentlich nichts, aber das Beispiel zeigt den prinzipiellen Aufbau.

#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
   int zahl2;

   /* Anweisungen */
   return 0;
}

Beschreibung:

#include <...>: Die Include-Direktive sagt dem Compiler, welche Header-Dateien er einbinden soll. In den Header-Dateien und den dazugehörigen Bibliotheken stehen Funktionen und Datentypen, die nicht im Compiler selbst implementiert sind, etwa komplexe Ausgabefunktionen wie "printf", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren +,-,*, etc. sind im Compiler selbst eingebaut.
int Zahl1;: Diese Zeile definiert eine Variable vom Typ int. Diese Variable ist im ganzen Programm gültig, sie ist global. Jede Deklaration/Anweisung in C wird mit einem Strichpunkt (Semikolon ;) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des Types char definiert.
int main (void): definiert ein Unterprogramm mit dem Namen main, das keine Parameter hat (void) und eine ganze Zahl (int) zurückliefert. "main" ist das Hauptprogramm in C, wo mit der Ausführung nach dem Programmstart begonnen wird.
{: Die linke geschwungenen Klammer beginnt den Rumpf (auch "body" genannt) der main-Funktion. Danach folgen Variablendefinitionen, Kommentare und Anweisungen von main.
int zahl2;: Innerhalb von "main" wird die lokale Variable zahl2 definiert.
/* Anweisungen */: Das ist ein Kommentar in C. Hier kann man Anmerkungen zum Code hinschreiben oder Codestücke "auskommentieren", um sie zu deaktivieren. Der Kommentar beginnt mit /* und wird beendet mit einem */. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit // akzeptiert, die nur bis zum nächsten Zeilenende reichen. Sie gehören jedoch nicht zum standard ANSI-C. Die Leerzeile nach dem Kommentar wird nicht weiter berücksichtig, sie kann zur Untergliederung des Codes zur besseren Lesbarkeit eingefügt werden.
return 0;: Gibt den Wert 0 zurück und beendet das Programm. Vor dem return können natürlich noch C-Anweisungen stehen, die aber erst weiter unten erklärt werden.
}: Die schliessende geschwungenen Klammer beendet den Rumpf des Hauptprogramms.

Das Hauptprogramm main

Die erste Funktion, die nach dem Programmstart ausgeführt wird, ist immer die Funktion mit dem Namen "main". Diese ist das Hauptprogramm.

Der main-Funktion können beim PC Parameter übergeben werden. Dies sind die sogenannten Kommandozeilenparameter, die beim Aufruf eines Programmes hinter dem Dateinamen stehen. Zudem wird auch ein int-Wert als Ergebnis zurückgeliefert, der den Aufrufer – üblicher weise eine Shell &ndahs; den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim Microcontroller ist main das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß main oft als void-Funktion (ohne Rückgabewert) definiert wird. Um Compilerfehler/Warnungen zu vermeiden, muss der Compiler dann aber mit speziellen Einstellungen gestartet werden, denn C-Standard ist, daß main einen Wert zurückliefert!

/* void-Definition von main ist nur beim Controller ueblich */
/* spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main */
/* kein Fehler/Warnung erzeugt wird. */
void main ()
{
    ...
}

Blöcke

Im vorigen Abschnitt haben Sie bereits die geschwungenen Klammern { und } kennen gelernt. Doch was bedeuten Sie? Einem Pascal-Kenner ist das schnell erklärt: { entspricht BEGIN, } entspricht END. Wenn ihnen auch das unbekannt ist, dann hilft Ihnen hoffentlich die folgende Erklärung. Programme sind in Abschnitte unterteilt. Da gibt es zum einen das Hauptprogramm und die jeweiligen Unterprogramme, aber auch Schleifen und bedingte Anweisungen. Jedes dieser Beispiele stellt ein eigenständiges Stück Code dar. Daher müssen Sie es auch als solches kennzeichnen. Dies geschieht mit { und }. { bedeutet so viel wie "Block Anfang" und } bedeutet "Block Ende":

int main (void)
{  /* der Block "main" beginnt */
   int zahl;
   
   {   /* ein Block beginnt */
       /* hier koennen Deklarationen und Anweisungen stehen */
   }   /* der Block endet */
  
   return 0;
}  /* "main" endet */

Datentypen

Elementare Datentypen

Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, welcher Art diese Daten sind und wie sie verarbeitet werden, etwa in arithmetischen Operationen wie einer Addition. So ist es zum Beispiel möglich, in eine Variable vom Typ int ganze Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können ASCII-Zeichen gespeichert werden (alles, was Sie mit der Tastatur erzeugen können) oder ganze Zahlen von -128 bis 127.

Achtung: Da C plattformabhängig ist, hängt die Größe eines Datentypes zum Teil von der genutzten Hardware (z.B. 8, 16 oder 32 Bit-Controller) und dem Compiler und dessen Einstellungen ab!

int, char, short, long (ganze Zahlen)

In Variable dieser Typen können Sie ganze Zahlen abspeichern, also z.B. 1, -2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "signed", also als vorzeichenbehafteten Typ, und als "unsigned", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

Vorzeichenbehaftete Ganzzahl-Typen werden intern im n-1-Komplement dargestellt, das Vorzeichen selbst findet sich also im höchstwertigen Bit. Werden zur Speicherung b Bits verwendet, dann reicht der Wertebereich von -2^b-1 bis zu 2^b-1-1.

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von 0 bis zu 2^b-1, wenn der Typ b Bits breit ist.

Größe (Bit)	Typ	Vorzeichen	Grenzen des Wertebereichs
8	`char`	`signed` `unsigned`	-128 0	127 255
16	`short`	`signed` `unsigned`	-32.768 0	32.767 65.535
32	`long`	`signed` `unsigned`	-2.147.483.648 0	2.147.483.647 4.294.967.295
64	`long long`	`signed` `unsigned`	-9.223.372.036.854.775.808 0	9.223.372.036.854.775.807 18.446.744.073.709.551.615
8, 16, 32, 64	`int`	`signed` `unsigned`	plattform-/compilerabhängig	plattform-/compilerabhängig

Boolean (Logische Variablen)

In der Sprache C gibt es keinen Datentyp für boolsche Werte "wahr" bzw. "TRUE" oder "falsch" bzw. "FALSE". Statt dessen wird gerne der Datentyp int dafür verwendet. Hat die jeweilige Variable den Wert 0, so ist sie FALSE, sonst (ungleich 0) ist sie TRUE.

Hinweis: Bitte beachten, daß eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

char (Zeichen)

In einer char-Variable können Sie 8-Bit-Werte speichern. Dieser Datentyp wird oft für ASCII-Zeichen genutzt, denn für den Computer ist es egal, ob sich eine Zahl oder ein Zeichen in der Variablen befindet. Er speichert alles in Form von Binärzahlen.

Dabei darf man eines nicht vergessen: Es macht einen großen Unterschied, ob man in einer char-Variablen das Zeichen '1' (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl 1 (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber '1' * 2 ergibt nicht '2', sondern 'b' (ASCII-Zeichen Nr. 98)!

float, double (Gleitkommazahlen)

In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654. float reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp double zum Einsatz.

Vorsicht: bei PIC (microchip) ist die innere Darstellung dieser Zahlen anders als bei den meisten anderen Compilern, beim binären Senden z.B. zum PC muß dann konvertiert werden! Bei avr-gcc finden die Rechnungen intern mit float statt, auch wenn ein Typ als double deklariert ist.

void

Dies ist ein spezieller Typ, der soviel bedeutet wie "nicht vorhanden". Eine Funktion, die keinen Rückgabewert zurückliefert, definiert als Rückgabetyp void, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ void können nicht angelegt werden.

Zeiger

Jede Variable steht an einer definierten Stelle im Speicher, an ihrer sogenannten Adresse.

Ein Zeiger ist eine Variable, in der eine Adresse gespeichert werden kann. Diese stellt eine bestimmte Position im Arbeitsspeicher dar. Die Adresse eines Objektes erhält man, indem man ihm ein & voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter *. Der Operator * gibt also den Inhalt der Adresse.

#include <stdio.h>

int main (void)
{
  int * zeiger;
  int zahl;
 
  zeiger = &zahl;
  *zeiger = 12;
  
  printf ("%d = %d", zahl, *zeiger);
  
  return 0;
}

Die Definition von zeiger als Zeiger ist so zu lesen: Der Inhalt von zeiger ist ein int. Damit wird zeiger zu einem "Zeiger auf int". Dabei gehört der * sinngemäß zum Bezeichner zeiger, nicht zum Typ. Folgende Definition definiert also nicht zwei Pointer, sondern einen Pointer (auf int) sowie einen int:

int * zeiger, zahl;

Um den Zeiger mit der Adresse von zahl zu laden, schreibt man den Adress-Operator & von zahl:

zeiger = &zahl;

Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" * (*zeiger = 12). Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an printf (und jedes andere Unterprogramm) übergeben.

Enum

Über enum können Aufzählungen definiert werden. Die Werte sind int-Werte und beginnen mit 0. Der folgende enum hat einen um 1 grösseren Wert. Mit einer Zuweisung können auch andere Werte zugeordnet werden. Klarer wird's im Beispiel:

enum Farben { ROT, GRUEN, BLAU, BRAUN = 3, SCHWARZ };

Dies definiert die Konstanten ROT=0, GRUEN=1, BLAU=2, BRAUN=3 und SCHWARZ=4 und den Typ enum Farben:

void foo (enum Farben farbe)
{
   switch (farbe)
   {
      case ROT:
         ...

Damit kann man anstatt "magischer" Zahlen sprechende Namen im Code verwenden, etwa in Berechnungen und Zuweisungen, Vergleichen oder als Konstante hinter einem case.

Zusammengesetzte Datentypen

Arrays

Oft muß man sehr viele Werte gleichzeitig abspeichern und betrachten, die alle der selben Aufgabe dienen. Man schreibt z.B. ein Programm, das 10 Zahlen einlesen und anschließend wieder ausgeben soll. Man könnte das natürlich mit 10 einzelnen Variablen bewerkstelligen, aber es ist sinnvoller, dabei Arrays – teilweise auch als Felder bezeichnet – zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_00 bis Zahl_99 arbeiten!

Syntax:

<Type> <Bezeichner>[<Konstante>];

Beispiel:

unsigned int werte[100];

Der Name muß natürlich ein gültiger Bezeichner sein, als Datentyp kann jeder Typ genommen werden &ndash sowohl elementare Datentypen als auch Zeiger, Strukturen, Unions oder selbst definierte Datentypen. In der eckigen Klammer wird die Anzahl der Elemente bekanntgegeben. Ein mit [3] definiertes Array hat Platz für drei Variablen. Da der Index immer bei 0 beginnt, greift man also mit [0], [1] und [2] auf den jeweilige Inhalt zu. Um auf eine der im Array enthaltenen Variablen zugreifen zu können, müssen Sie den Variablennamen und in eckigen Klammern den Index (die "Nummer") der Variablen angeben. Diese Variable verhält sich dann wie eine ganz normale Variable des jeweiligen Datentypes.

#include <stdio.h>

#define NZAHLEN 10

int main(void)
{
   int i;
   int zahlen[NZAHLEN];  /* zahlen[0] ... zahlen[9] */
 
   for (i=0; i < NZAHLEN; i++)
   {
      printf ("Bitte Zahl %d eingeben: ", i);
      scanf  ("%d", & zahlen[i]);
      printf ("\n");
   }

   printf ("Super!\n");
   
   for (i=0; i < NZAHLEN; i++) 
      printf ("Zahl %d ist: %d\n", i, zahlen[i]);
     
   return 0;
}

Zuerst wird ein 10 int-Variablen großes Array angelegt. In dieses wird nun der Reihe nach 10 Zahlen eingelesen. Anschließend werden alle 10 Zahlen ausgegeben.

Dabei wird die Größe der Arrays und das Schleifenende über das Define "NZAHLEN" angegeben. Dadurch muss nur eine Stelle im Code geändert werden, wenn die Größe des Arrays einmal einen anderer Wert als 10 haben soll – dies vermeidet Fehler die dadurch entstehen, wenn man beim Anpassen der Array-Größe eine Codestelle vergisst, zudem wird der Code lesbarer als wenn irgendwo die Zahl "10" auftaucht.

Merke:

Wird ein ungültiger Index angeben (einer, der in der Deklaration nicht enthalten ist) können undefinierte Dinge passieren, wenn dadurch andere Variableninhalte oder Programmcode überschrieben wird, der hinter oder vor dem Array im Speicher liegt. Schlimmstenfalls kann sogar der Computer/Controller abstürzen. Also darauf achten, daß keine ungültigen Werte als Index auftreten!

Strings (Zeichenketten)

Ein String ist nichts anderes als ein Array, das aus einzelnen Zeichen (char) gebildet wird. Die Ausgabe auf dem Bildschirm funktioniert am einfachsten mittels Strings.

Die Definition eines Strings erfolgt also genauso wie bei Arrays:

char string[21];

Nun haben Sie eine String, in dem Sie 21 Zeichen speichern können. Ganz richtig ist das jedoch nicht. C arbeitet mit "null-terminierten Strings". Das beudeutet, dass die Länge des Strings nicht abgespeichert wird, sondern das Zeichen mit dem ASCII-Wert 0 das Stringende kennzeichnet. Daher auch die Bezeichnung "null terminiert".

Das letzte Zeichen eines Strings muß daher immer das ASCII-Zeichen Nr. 0 sein. Ist es das nicht, hat der String kein definiertes Ende, und wenn Sie versuchen, ihn durch eine Standard-Funktion auszugeben zu lassen, könnte es eine Weile dauern, bis sich im Speicher zufällig irgendwo eine 0 befindet. Es stehen ihnen daher bei dem Beispiel nur 20 Zeichen zur Verfügung.

Mehrdimensionale Arrays

Manchmal benötigt man mehr als nur ein eindimensionales Array, wie Sie es bisher kennengelernt haben. Auch dies ist kein Problem. In der Deklaration geben Sie einfach mehrere eckige Klammern hintereinander an. Aber Vorsicht: der Speicherplatz ist begrenzt, ein "char feld[1024][1024]" hat die Speicherplatzgrenzen vermutlich bereits weit überschritten, und der Compiler wird einen (bei gewissen Einstellung auch keinen) Fehler liefern. Beim Zugriff auf mehrdimensionale Felder müssen auch mehrere Indizes angeben werden:

#include <stdio.h>

int main(void)
{
  int x,y;
  int feld[3][5];
 
  for (x=0; x<3; x++) 
  {
     for (y=0; y<5; y++)
     {
       printf ("Feldwert x: %d,  y: %d ", x, y);
       scanf  ("%d", & feld[x][y]);
       printf ("\n");
     }
  }

  for(x=0; x<3; x++) 
     for (y=0; y<5; y++) 
        printf ("Wert: feld[%d][%d] = %d\n", x, y, feld[x][y]);

  return 0;
}

Erklärung:

Zuerst wird ein 3 mal 5 int-Array angelegt. Dann werden die Werte eingegeben: zuerst feld[0][0], dann feld[0][1], usw. bis feld[2][4]. Zum Schluß werden alle Werte noch einmal ausgegeben.

Strukturen

In C können Sie sogenannte "Strukturen" definieren. Dabei handelt es sich um eine Zusammenfassung mehrerer Datentypen zu einem größeren. Im Unterschied zu Feldern können in Strukturen unterschiedliche Datentypen zusammengestellt und gespeichert werden:

Syntax:

struct <Bezeichner>
{
   <Deklaration>
   <Deklaration>
   ...
};

Beispiel:

/* Definition der Struktur 'Person' */
struct Person 
{
   int id;
   char vname[20], nname[20];
   char telnr[15];
   int alter;
};

"struct Person {" leitet die Definition der Struktur mit dem Namen "Person" ein. Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei int. mit } wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs struct Person anzulegen, geben Sie einfach an

struct Person <Bezeichner>;

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also hubert bzw. klaus), einen Punkt und danach den Bezeichner der Komponente:

/* Definition zweier Struktur-Variablen */
struct Person hubert, klaus;

/* Zugriff auf Struktur-Komponenten */
hubert.alter = 32;
klaus.alter = hubert.alter + 1;

Unions

Eine Union wird ganz analog zu einer Struktur deklariert und verwendet. Sie unterscheidet sich von einer Struktur jedoch dadurch, daß ihre Elemente nicht nacheinander im Speicher abgelegt werden, sondern sich überlagern. Auf die in einer Union enthaltenen Daten gibt es also verschiedene Sichten: je nachdem, welche Sicht bzw. Interpretation der Daten man gerne hätte, wählt man den gewünschten Zugriff.

union Daten 
{
   int id;

   struct Person u_person;

   struct u_double
   {
      int id;
      double wert;
   };

   struct u_pointer
   {
      int id;
      union Daten * p1;
      union Daten * p2;
   };
};

union Daten data;

Dies definiert eine Union mit den vier Zugriffsmöglichkeiten id, u_person, u_double und u_pointer. Die Größe der Union richtet sich dabei nach der grössten Komponente. In diesem Beispiel sind alle Komponenten so angelegt worden, daß sie an erster Stelle ein int id enthalten. In data.id könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde struct Person nicht dieses id enthalten, so würde sich data.id mit data.u_person.vname überlagern. Ein Ändern der ersten Buchstaben von vname hätte also ein Ändern von id zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das id von data die id-Felder der anderen Sichten, z.B. ist data.id der selbe Zugriff wie auf data.u_person.id.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines long zuzugreifen:

typedef union
{
   unsigned long  as_long;
   unsignen short as_short[2];
   unsignen char  as_byte[4];
} data32_t;

Dies überlagert einen unsigned long – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.

data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
/* nun ist wert.as_long gleich 0xab345678 oder 0x123456ab (je nach Plattform) */

Eigene Datentypen

Variablen

Eine Variable ist ein Synonym (=anderer Name) für eine Speicherstelle in einem Computer. Einfacher gesagt, eine Variable bietet Raum, um Daten wie Zahlen oder Zeichen zu speichern und wieder zu lesen.

Variablennamen

Ein Variablenname kann zusammengesetzt werden aus den Buchstaben A bis Z und a bis z, den Ziffern 0 bis 9, sowie dem Sonderzeichen "Unterstrich" (underscore) _. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner hallo, HALLO, Hallo, HALL0, _123 und _HALLO sind also alle gültige und unterschiedliche Variablennamen.

Anlegen von Variablen

Um eine Variable verwenden zu können, muss sie zuerst vereinbart ("erzeugt") werden. Dies wird auch als "Definition der Variablen" bezeichnet und geht so: Schreiben Sie zuerst den Datentyp, dann den Namen der Variablen. Zum Schluß kommt noch der Strichpunkt, wie nach jeder C-Anweisung oder Deklaration. Und nicht vergessen: C unterscheidet zwischen Groß- und Kleinschreibung!

int Zahl1, Zahl2;
char Zeichen;

int main (void)
{
   float gleitZahl;
   /* Anweisungen */

   return 0;
}

Erklärung: In einer Zeile können auch mehrere Variablen gleichen Types vereinbart werden, wenn man ein Komma dazwischen setzt. Variablen können in jedem Block vereinbart werden. Siehe Gültigkeitsbereich.

Zuweisungen

Man kann einer vereinbarten Variable Werte zuweisen. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "=" und anschliessend den zuzuweisenden Ausdruck.

int main (void)
{
  int zahl1, zahl2 = 12;
  char zeichen1 = 'A';

  zahl1 = 52;
  zeichen1 = zeichen1 + 1; 

  return 0;
}

Zuerst werden drei Variablen angelegt (zahl1, zahl2, zeichen1).

zahl2: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
zahl1 = 52: Hier wird der Variablen zahl1 der Wert 52 zugewiesen.
zeichen1: wird um 1 erhöht. Da in der Variablen 'A' gespeichert ist, gibt sich ihr neuer Wert aus 'A' + 1. Weil 'A' dem Wert 65 entspricht, ist 'A' + 1 gleich 66, was dem Wert für 'B' entspricht.

Zuweisungen bei float

Das funktioniert genau wie bei normale Zuweisungen. Nachkommastellen werden durch einen Punkt abgegrenzt:

floatVariable = 3.14;

Zusätzlich kann eine Zehnerpotenz angegeben werden:

floatVariable2 = -1.234E-6;

Dadurch wird der erst Wert mit 10^-6 multipliziert, der Wert der Variablen ist also

[math]-1{,}234\cdot10^{-6} = -0.000001234[/math].

Zuweisungen bei logischen Variablen

Wie bereits erwähnt, besitzt C keinen logischen Datentyp. Es müssen also int oder char dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "wahr", ansonsten ist sie "unwahr".

intVariable = !0;   /* entspricht "wahr"   */
intVariable = 0;    /* entspricht "unwahr" */

Konstanten

Konstanten können als Variable angesehen werden, die nicht beschrieben, sondern nur gelesen werden können. Ein typisches Beispiel dafür ist die Zahl [math]\pi[/math] (rund 3,141592654). Niemand würde in der realen Welt versuchen, ihr einen anderen Wert zuzuweisen. Würde man [math]\pi[/math] jedoch wie eine normale Variable anlegen, wäre dies ohne weiteres möglich. Um dies zu verhindern, gibt es dafür ein Schlüsselwort in C:

const datentyp name = value;  /* Zuweisung bei der Defininition der Variablen */

Wichtig dabei ist, dass man Konstanten nur bei der Vereinbarung einen Wert zuweisen kann. Da Konstanten gewöhnlich im gesamten Programm, zumindest einer Quelldatei genutzt werden, definiert man diese allerdings gewöhnlich außerhalb des main-Blockes entweder am Anfang eines Programmes, oder in einer sogenannten Header-Datei, die per #include eingebunden wird.

const float PI = 3.141592;  /* Zuweisung bei der Defininition der Variablen */

Es sei jedoch erwähnt, daß auch einer Konstanten nachträglich ein anderer Wert zugewieden werden kann. Im obigen Beispiel könnte mit

* ((float*) &PI) = 2;

der Wert von PI im Nachhinein verändert werden. Es wird die Adresse von PI genommen und diese Adresse durch den Cast in eine ganz normale float-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das const bei einer Pointer-Deklaration befindet, markiert es den Pointer als konstant oder das Objekt, auf das dieser Pointer zeigt. Eine häufige Parameterdeklaration in Ausgabe-Funktionen, die einen String erhalten, ist

void foo (const char * str, ...);

Dadurch ist str der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie *str = 'a' ergibt also einen Fehler. str selbst kann aber sehr wohl verändert werden, etwa mit str++.

Soll ausgedrückt werden, daß str unveränderlich ist, dann so:

void foo (char * const str, ...);

Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch str[10] = 'a'. Um sich zu merken, worauf das const wirkt, trennt man die Deklaration in Gedanken beim * auf: Steht das const links vom *, dann gehört es zum char, steht es rechts davon, dann gehört es zum Pointer. Natürlich ist es auch denkbar, beides – also den Zeiger und sein Ziel – als konstant zu markieren.

Gültigkeitsbereich

In C können mehrere Variablen den gleichen Namen haben, solange eindeutig ist, welche in welchen Block gültig ist. Dabei gelten folgende Regeln:

Lokale Variablen: sind Variablen, die innerhalb eines Blockes definiert werden. Jede Variable ist nur in dem Block gültig, in dem sie vereinbart wurde, sowie in allen darin enthaltenen Blöcken; es sei denn, in einem Unter-Block wird eine Variable gleichen Namens definiert. Dann bezieht sich in diesem Unter-Block der Bezeichner auf die im Unter-Block angelegte Variable.
Globale Variablen: werden ausserhalb jedes Blockes definiert und gelten ab der Stelle, an der sie deklariert werden, siehe auch Deklaration und Definition. Wird jedoch in einem Block eine Variable gleichen Namens angelegt, gilt ab hier bis zum Ende des Blocks nicht mehr die globale Variable, sondern die im Block deklarierte. Das Spiel kann man weiterspielen: wird in einem Unter-Block wieder eine namensgleiche Variable angelegt, gilt diese in dem Unterblock.

Speicherklassen

Jede Variable in C gehört zu einer bestimmten Speicherklasse

auto: Lokale Variablen sind in aller Regal sogenannte automatische Variablen. Das bedeutet, sie werden automatisch angelegt, wenn ein Block bzw. eine Funktion betreten wird und danach wieder entfernt. Das Schlüsselwort "auto" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
extern: Eine externes Symbol ist im ganzen Programm bekannt bzw. in dem Block, in der die Deklaration steht. In unterschiedlichen Blöcken stehende Deklarationen beziehen sich auf das gleiche Symbol! Obgleich das Datum global zugreifbar ist, ist der Gültigkeitsbereich auf den deklarierenden Block begrenzt bzw. auf das deklarierende Quell-Modul, sofern das Symbol ausserhalb jedes Blocks des Moduls deklariert wird. Siehe auch Deklaration und Definition.
static: Die Variable ist im Block gültig bzw. im Quell-Modul (also in der C-Datei, in der die angelegt wurde), wenn sie nicht innerhalb eines Blockes angelegt wurde. Statische Variablen werden nicht in Registern oder im Frame der Funktion angelegt, sondern im selben Speicherbereich, in dem auch die globalen Variablen liegen; Konstanten evtl. auch im Flash. Eine lokale Variable, die als static angelegt wird, "überlebt" also das Verlassen des Blocks und hat beim neuerlichen Betreten des Blockes ihren bisherigen Wert. In unterschiedlichen Blöcken angelegte lokale statische Variablen beziehen sich auf unterschiedliche Speicherstellen, genau wie bei lokalen Variablen auch.
register: Durch diese Speicherklasse wird eine Variable – falls möglich – als Registervariable angelegt, also in einem Maschinenregister des Computer/Controllers gehalten. Dadurch kann auf solche Variablen besonders schnell zugegriffen werden. Dieses Schlüsselwort ist bei modernen Compilern weitgehend überflüssig, da die entsprechenden Optimierungen selbständig vorgenommen werden, wenn ausreichend Register vorhanden sind. Auch globale Variablen können als Register angelegt werden, davon ist dem Anfänger aber dringend abzuraten, weil leicht schwerauffindbare Fehler und Abstürze auftreten, wenn man nicht genau weiss, welche Implikationen in einer solchen Definition stecken!
volatile: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von register und bewirkt, dass die Variable auf keinen Fall in einem Register zwischengespeichert werden darf, sondern immer aus dem RAM gelesen und ins RAM geschrieben werden soll. volatile müssen alle globalen Variablen markiert werden, die in Interrupt-Handlern verwendet werden.

Ausdrücke

Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar. Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.

Einfache Beispiele für Ausdrücke sind also z.B.:

1
a
'a'
1 + a
a == 1

Auch Funktionen können einen Wert zurückliefern und in Ausdrücken weiter benutzt werden. In den folgenden Abschnitten wird gezeigt, welche Operatoren in C vorhanden sind, und wei man damit neue Ausdrücke aufbauen kann.

Lvalues

Ein Lvalue in C ist ein Ausdruck, dem ein anderer Ausdruck zugewiesen werden kann, dessen Wert also durch eine Zuweisung verändert werden kann. das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in alles Regel nicht.

Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit const als Konstante markiert ist:

a = 1;

Hingegen ist der Ausdruck a+1 kein Lvalue, denn eine Zuweisung wie

a+1 = 2;

die mathematisch durchaus sinnvoll ist, erzeugt einen Compilerfehler, der etwa lauten könnte "illegal lvalue in assignment": "ungültiger Wert in Zuweisung"

Andere Beipiele für Lvalues sind die Komponenten von (nicht-konstanten) Strukturen und Unions, Array-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung * wird an die Adresse 4 im Speicher eine 3 geschrieben. Ob das erlaubt bzw. sinnvoll ist, ist abhängig von der jeweiligen Architektur.

* ((unsigned int *) 4) = 3;

Hier ist der gesamte *-Ausdruck ein Lvalue

Logische (boolsche) Operatoren

Ausdruck	Beschreibung
`a && b`	wahr, wenn `a` wahr und `b` wahr
`a \|\| b`	wahr, wenn `a` wahr oder `b` wahr
`a == b`	gleich
`a != b`	ungleich
`a <= b`	kleiner oder gleich
`a < b`	kleiner als
`a >= b`	glösser oder gleich
`a > b`	grösser als
`!a`	wahr, wenn `a` nicht wahr und vice versa

Eine interessante Eigenschaft der Operatoren && und || ist, dass sie die Auswertung abbrechen, sobald das Ergebnis feststeht. Die Ausdrücke werden dabei immer von links nach rechts ausgewertet. Ein oft anzutreffendes Codestück sieht so aus, dabei sei p ein Zeiger auf einen int:

Beispiel:

 if (p && *p == 5)
 {
    /* mach was */
 }

Zuerst wird in der Bedinung geprüft, ob Zeiger p einen Wert ungleich Null hat, also ob er überhaupt einen gültigen Wert enthält. Es ist weit verbreitete Konvention in C, daß Zeiger, die keinen gültigen Wert haben, die Adresse 0 enthalten. Nur dann, wenn ein Zeiger nicht ein Null-Pointer ist, darf überhaupt ein Zugriff über ihn erfolgen!

Vergleich von Variablen

Skalare Variablen (also ganze Zahlen, Gleitkommazahlen, Zeiger) können miteinander verglichen werden. Dazu gibt es die folgenden Operatoren in C:

Operator	Bedeutung
`==`	ist gleich
`!=`	ist nicht gleich
`<`	ist kleiner
`<=`	ist kleiner oder gleich
`>`	ist größer
`>=`	ist größer oder gleich

Das Ergebnis der Auswertung ist eine ganze Zahl. Ist die Bedingung erfüllt, dann ist der Wert ungleich 0. Ist die Bedingung nicht erfüllt, dann ist ihr Wert gleich 0. Meistens wird man diese Operatoren in if-Konstrukten finden wie zum Beispiel

if (x >= 10)
   x = 10;

oder in Abbruchbedingungen von Schleifen, wie sie weiter unten erklärt werden.

Es ist auch möglich, das Ergebnis der Auswertung in einer int-Variablen zu speichern:

int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1;  /* Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist */

Die Variable i ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist i gleich 0 ("unwahr").

Arithmetische Operatoren

Ausdruck	Beschreibung
`a + b`	Summe (Addition)
`a - b`	Differenz (Subtraktion)
`a * b`	Produkt (Multiplikation)
`a / b`	Quotient (Division, evtl. mit Rest)
`a % b`	Rest bei Division (Modulo)
`-a`	Vorzeichenumkehr (Zweierkomplement)

Bit-Operatoren

Ausdruck	Beschreibung
`a & b`	bitweise und (and)
`a \| b`	bitweise oder (or)
`a ^ b`	bitweise exclusiv-oder (xor, exor)
`~a`	jedes Bit in `a` invertieren (not, Einerkomplement)

Index-Operator bei Arrays

Ausdruck	Beschreibung
`a[b]`	das (b+1)ste Element des Feldes a

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

a muss ein Feld oder Zeiger sein
b muss ein Integer sein oder ein Datentyp, der sich in einen int umwandeln läßt (z.B. char)
Es wird nicht geprüft, ob der Index b im Feld a gültig ist!
Der erste Index eines Feldes ist immer 0. Daher (b+1)stes Element in der Beschreibung

Komponenten-Auswahl bei Structs und Unions

Ausdruck	Beschreibung
`a.b`	Element b der Struktur oder des Unions a

Adress-Operator und Dereferenzierung

Ausdruck	Beschreibung
`&a`	Speicheradresse der Variablen `a`
`*a`	Wert, der an der Adresse `a` steht
`a->b`	Wert des Elements `b` der Struktur, deren Adresse in `a` steht

Der Adressoperator & kann auf Variablen angewendet werden und gibt die Startadresse der Variablen im Speicher zurück.

Handelt es sich bei einer Variable um einen Zeiger, so enthält sie eine Speicheradresse. Um an den Wert zu gelangen, der an dieser Adresse steht, wird der Operator * vorangestellt.

Beispiel:

/* x ist eine Integervariable und hat den Wert 5 */
int x = 5;
    
/* z ist ein Zeiger auf eine Integervariable und enthaelt somit */
/* die Speicheradresse einer Integervariablen */
int *z;       
 
/* Verwendung des Adress-Operators */
z = &x;       /* weise z die Speicheradresse von x zu */

/* Verwendung der Dereferenzierung */
/* erhoehe den Wert, der bei Adresse z steht um eins */
*z = *z + 1;

/* da z auf x zeigt, hat x jetzt den Wert 6 */

Da in C häufig Zeiger auf Strukturen verwendet werden, ist für den Zugriff auf ein Element eine abkürzende Schreibweise möglich:

Statt

 (*strukturZeiger).element

kann geschrieben werden

 strukturZeiger->element

Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

Achtung!

Bei der Dereferenzierung durch * findet keine Prüfung statt, ob der Zeiger auch

auf eine gültige Speicheradresse verweist. Folgendes Codestück führt zum Absturz oder zu einer Änderung irgendeiner Speicherstelle!

int *z; /* z ist ein Zeiger auf einen int */

/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen. */
/* z enthaelt irgendeine ungueltige Adresse!! */

/* "Erhoehe einen Integer _irgendwo_ im Speicher um 1" -> CRASH !!! */
*z = *z + 1;

Viele C-Compiler erzeugen in der Standardeinstellung für das obige Codestück keine Warnung!

Cast-Operator

Der Cast Operator dient dazu, den Datentyp eines Wertes zu ändern. Dafür wird einfach der neue Datentyp in Klammern vor den Wert geschrieben.

Um zum Beispiel aus einem Float ein Integer zu machen:

var  = (int) 5.60;

Dabei wird der Wert aber auch gerundet, und es findet somit ein Informationsverlust statt.

Ein weiteres Beispiel ist das Umwandeln einer ganzen Zahl in eine Adresse:

int * addr;
addr = (int*) 0x1234;

Damit ist addr ein Zeiger auf einen int an Adresse 0x1234.

Achtung!

Der Cast-Operator selbst führt keine Konvertierung durch, sondern unterdrückt nur die Compilerwarnungen oder -fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in eine Zahl oder umgekehrt zu wandeln:

  #include <stdio.h>
  int main(int argc, char ** argv)
  {
        char text[] = "5.6";
        int zahl = (int)text;

        printf("%d\n", zahl);

        return 0;
  }

Ausgegeben wird weder 5 noch 6 sondern die Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator unterdrückt nur die Warnung, die auf den Fehler hinweisen will.

Komma-Operator

Mit einem , können mehrere Ausdrücke nacheinander ausgewertet werden. Die Auswertung erfolgt von links nach rechts.

Solche Konstrukte sieht man manchmal in Abfragen wie

FILE  *file;
if (file = fopen ("foo.exe", "r"), file != NULL)

was erst an file einen Wert zuweist und den if-Block nur betritt, wenn file nicht der Nullpointer ist.

Zuweisungen und Operatoren mit Nebeneffekt

Bedingter Ausdruck

(<Bedingung>) ? <Ausdruck1> : <Ausdruck2>

Wenn Bedingung erfüllt ist, dann wertet dieser Ausdruck aus zu Ausdruck1. Ist er nicht erfüllt, dann wertet er aus zu Ausdruck2.

Beispiel:

x = (x >= 3) ? 0 : x+1;

Startet man x mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:

1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...

Reihenfolge der Auswertung

Boolsche Logik

Boolean-Variablen können miteinander verknüpft werden. Dies geschieht mit den boolschen Operatoren && ( logisches "und"), || (logisches "oder") und ! (logisches "nicht") (es gibt noch weitere, auf die hier nicht eingegangen wird).

b1= b2 && b3;

Der Wert von b1 ist dann 1 (TRUE), wenn b2 und ("AND") b3 1 (TRUE) sind. Ist eine der beiden (oder auch beide) 0 (FALSE), dann ist b1 ebenfalls 0 (FALSE).

b1= b2 || b3;

Der Wert von b1 ist dann TRUE, wenn b2 oder ("OR") b3 TRUE ist. Ist also einer (oder beide) TRUE, dann ist auch b1 TRUE, sind beide FALSE, ist auch b1 FALSE.

b1= !b2;

Der Wert von b1 ist dann TRUE, wenn der von b2 FALSE ist. Die NOT Verknüpfung "dreht den logischen Wert der Variablen um".

Kontrollanweisungen

if-Anweisung

Syntax

if (<Bedingung>)
   <Anweisung>

Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen. Im Flussdiagramm sieht eine if-Anweisung folgendermassen aus:

Und in C schreibt man:

if (Bedingung)        /* WENN */
{                     /* DANN */
       Anweisung1;
       Anweisung2;
       ...
}
else
{                     /* SONST */
       Anweisung3;
       Anweisung4;
       ...
}

Wenn die Bedingung wahr ist, wird Anweisung1 ausgeführt. Anschliessend wird aus der if-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr, dann wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird der if-Befehl beendet.

Ein häufiger Fehler ist es, statt if (a == 23) etwas wie if (a = 23) zu schreiben. Dann wird allerdings nicht geprüft, ob die Variable a gleich 23 ist, sondern der Variablen a wird der Wert 23 zugewiesen. Der Ausdruck a = 23 hat den Wert 23 und ist damit immer "wahr", daher ist die if-Bedingung immer erfüllt!

Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken sondern bestenfalls eine Warnung. Damit ist dieser Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if (23 == a). Wenn man dort anstatt des Vergleichsoperators '==' den Zuweisungsoperator '=' verwendet, spuckt der Compiler sehr wohl einen Fehler aus! Ist die Zuweisung jedoch erwünscht und eine Compiler-Warnung lästig, dann wählt man eine Schreibweise wie if ((a = b)) oder if (a = b, a).

Ein weiterer häufiger Fehler ist zu schreiben if (Bedingung); Richtig muss es heissen "if(Bedingung)" Das Semikolon im ersten Fall ist eine leere Anweisung, die im if-Falle ausgeführt wird – sie bleibt also ohne Resultet. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt; ein auf das Semikolon folgende Anweisung die eigentlich zum if gehören soll wird immer ausgeführt, die sie nicht mehr zum if dazu gehört.

switch-Anweisung

Syntax:

switch (<Ausdruck>) 
{
    case konstante1:
        <Anweisung>
        <Anweisung>
        ...
   
    case konstante2:
        <Anweisung>
        <Anweisung>
        ...

    ...  

    default:
        <Anweisung>
        <Anweisung>
        ...
} /* Ende von switch */

Der Ausdruck muss ein skalarer Typ sein, er wird in die nächste ganze Zahl gewandelt und mit den Werten hinter den case-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden case ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der default-Abschnitt ausgeführt falls vorhanden.

Auch die Anweisungen der nachfolgenden case- und des default-Abschnitts werden ausgeführt, wenn die Anweisungen des case-Abschnitts nicht mit dem Befehl break; beendet werden!

Es dürfen beliebig viele case-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer. Der default-Abschnitt ist optional. Die Reihenfolge, in der case und default angegeben werden, ist unerheblich.

Schleifen

Um Anweisungen mehrmals hintereinander auszuführen, benötigt man Schleifen. Diese führen Anweisungen aus, bis oder solange Bedingungen erfüllt sind.
Wichtig ist also, ob die Bedingung vor oder nach den Schleifen-Anweisungen geprüft wird.

while-Schleife

Syntax:

while (<Bedingung>)
   <Anweisung>

Die while-Schleife wird solange durchlaufen, wie die Bedingung erfüllt ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Die Anweisung kann natürlich auch ein Block sein, der aus mehreren Deklarationen und Anweisungen besteht.

int zahl1 = 0;
int zahl2 = 1;

while (zahl1 < 3)
{
   zahl1 = zahl1 + 1;
   zahl2 = zahl2 * 2;
}

In diesem Beispiel wird die Schleife drei mal durchlaufen. Zu Beginn des vierten Durchlaufs ist die Bedingung nicht mehr erfüllt (zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.

do-while-Schleife

Syntax:

do
   <Anweisung>
while (<Bedingung>);

Die do-while-Schleife wird auf jeden Fall einmal durchlaufen und dann solange wiederholt, wie die Bedingung erfüllt ist.

int i = 2;
do 
{
    i = i*i;   /* i quadrieren */
    printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange i kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben.

for-Schleife

Syntax:

for (<Ausdruck1>; <Bedingung>; <Ausdruck2>)
   <Anweisung>

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa i=0 oder i=i+2. Es werden folgende Aktionen ausgeführt:

Ausdruck1 wird ausgewertet
Bedingung wird ausgewertet
falls die Bedingung wahr ist, dann führe Anweisung aus.
falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
Ausdruck2 wird ausgewertet
gehe zu 2
nächste Anweisung nach der for-Schleife

Beispiel:

int lauf, summe;

for (lauf=1, summe=0; lauf <= 10; lauf += 2) 
{
   summe += lauf;
}

In diesem Beispiel ist Ausdruck1 ein Komma-Ausdruck, der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt lauf auf 1 und summe auf 0.

Das Äquivalent als while-Schleife:

int lauf  = 1;                 /* Anfangswerte */
int summe = 0;

while (lauf <= 10)             /* Bedingung */
{
   summe += lauf;
   lauf  += 2;                 /* Inkrement */
}

In diesem Beispiel wird summe in jedem Schleifendurchlauf um die Laufvariable lauf erhöht. Da lauf nacheinander die ungeraden Werte von 1 bis 10 annimmt, ist in summe nach der Schleife die Summe der ungeraden Zahlen von 1 bis kleinergleich 10 gespeichert, also der Wert 25. lauf hat nach der Schleife den Wert 11.

Erklärung: lauf = 1 bedeutet, dass der Variablen lauf vor dem ersten Schleifendurchlauf der Wert 1 zugewiesen wird. lauf <= 10 ist die Schleifenbedingung; ist sie nicht erfüllt, wird die Schleife beendet. lauf += 2 bedeutet, dass lauf nach jedem Durchlauf um 2 erhöht wird.

Ein- und Ausgabe

Bildschirm-Ausgabe

Bisher war das Tutorial trotz aller Beispiele reine Theorie. Sie konnten zwar Programme schreiben, aber die Funktion nicht testen. Hier lernen Sie nun, wie Sie etwas am Bildschirm ausgeben.

Die dazu notwendige Funktione heisst printf (das 'f' ist kein Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf das Standard-AUsgabegerät aus, in der Regel also auf den Bildschirm. Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. int, </tt>char</tt>, double...) sein!

#include <stdio.h>

int main (void)
{
    int zahl1 = 12;
    char zeichen1 = 'A';
    
    printf ("Das ist Text, und er wird als solcher ausgegeben. \n");
    printf ("Der Wert der Variablen 'zahl1' ist: %d \n", zahl1);
    printf ("Der Wert der Variablen 'zeichen1' ist: %c \n", zeichen1);
    printf ("Der Wert der Variablen 'zeichen1' ist: %d \n", zeichen1);
    
    return 0;
}

Der erste printf-Befehl gibt Text aus. Das Zeichen am Ende (\n) bedeutet "New Line", es bewegt den Cursor an den Anfang der nächsten Zeile.

Der zweite printf-Befehl gibt auch Text aus, am Ende befindet sich wieder das \n, um einen Zeilenvorschub zu erreichen. Das %d wird vom Compiler durch den ersten Parameter ersetzt, der nach dem Text angegeben wird. In diesem Fall wird %d also durch den Wert der Variablen zahl1 ersetzt. Das d im %d bedeutet "Dezimalzahl", der Computer gibt also eine ganze Zahl aus.

In der dritten Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet %c "char" (Zeichen). Es wird also %c durch ein A ersetzt, denn die Variable zeichen1 wird als Character interpretiert.

Die letzte Ausgabe interpretiert den Inhalt von zeichen1 als Zahl, und gibt dager den ASCII-Wert von A, also 65 aus. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer Variablen!

Tastatur-Eingabe

Um ein "gscheites" Programm schreiben zu können, muß man wissen, wie der Benutzer über die Tastatur Befehle eingeben kann. Die dafür notwendigen Funktionen stelle ich in diesem Kapitel vor. Die wichtigste Funktion ist scanf. Er liest Daten von der Tastatur. Die Syntax entspricht derer von printf:

int  zahl1;
char zeichen1;

printf ("Bitte geben Sie eine Zahl ein: ");
scanf  ("%d", &zahl1);
printf ("Geben Sie einen Zeichen ein: ");
scanf  ("%c", &zeichen1);

Das Programm gibt eine Eingabeaufforderung aus. Dann erwartet es vom Benutzer, daß er eine Zahl eingibt, die mit [ENTER] bestätigt wird. Dieser Wert wird in zahl1 abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

Macht man keine dem Datentyp der erwarteten Variable entsprechende Eingabe, dann bricht das Programm mit einer Fehlermeldung ab (wenn man z.B. "1_T2" eingibt, wenn eine Zahl erwartet wird)!

Das & vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm scanf bekommt zwar einen Wert übergeben, kann aber keinen zurückliefern ("call by value"). Daher wird kein Wert, sondern ein Zeiger auf eine Variable übergeben. Mit dem & Zeichen bekommen Sie die Adresse einer Variablen ("call by reference").

Allgemeines zu Unterprogrammen

Stellen Sie sich vor, Sie haben einen eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben (was Zeit beim Erstellen und Speicherplatz im ausführbaren Programm kostet), können Sie den Abschnitt in ein sogenanntes "Unterprogramm" schreiben. Dieses Unterprogramm können Sie dann von jeder Stelle ihre Hauptprogrammes aus aufrufen. Anders als in anderen Programmiersprachen gibt es in C keine generelle Unterscheidung zwischen Funktionen und Prozeduren. Trotzdem möchte ich kurz darauf eingehen:

Funktionen

Syntax: Rückgabe-Typ Name(Parameterliste);

Funktionen sind Unterprogramme, die am Ende der Ausführung einen Wert zurückliefern, wie z.B. getch. Paradebeispiele für die Anwendung einer Funktion sind jedoch mathematische Formeln:

#include <stdio.h>

int hoch2 (int param1)
{
  int zahl;
  zahl = param1 * param1;
  return zahl;
}

int main (void)
{
  int zahl1, ergebnis;
  
  printf ("Bitte Zahl eingeben: ");
  scanf  ("%d",&zahl1);
  
  ergebnis = hoch2 (zahl1);
  
  printf ("%d hoch 2 = %d\n",zahl1, ergebnis);
  printf ("5 hoch 2 = %d\n", hoch2(5));
  
  return 0;
}

Bemerkungen zum Programm: Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen. Geschachtelte-Unterprogramme sind in Standard-C nicht möglich. In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Danach folgt der Name der Funktion (case-sensitiv!). Dann kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden und mittels Komma voneinander getrennt werden. Im Block der Funktion können lokale Variablen definiert werden und alle Anweisungen ausgeführt werden. Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung return und dem Rückgabewert. Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an

variable = Funktion (Parameter);
Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).

Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

Prozedur

Syntax: void Name (Parameterliste)

Eine Prozedur ist nichts anderes als eine Funktion mit dem speziellen Rückgabetyp void, der kennzeichnet, daß die Funktion keinen Wert zurückliefert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede:

Als Rückgabe-Datentyp wird void angegeben. Einer Variablen kann daher nicht der Rückgabewert einer void-Funktion zugewiesen werden, da diese garkeinen Rückgabewert liefert.

#include <stdio.h>

void ausgeben (int param1)
{
  printf ("Der Wert der Variablen ist: %d\n", param1);
}

int main(void)
{
   int zahl1 = 4;
   
   ausgeben (23);
   ausgeben (zahl1);
   
   return 0;
}

Bemerkungen zum Programm: Durch den Befehl "ausgeben(23)" wird die Prozedur "ausgeben" mit dem Parameter 23 aufgerufen. param1 hat also den Wert 23. Die einzige Anweisung innerhalb der Prozedur ist printf, was nun ausgeführt wird. Der zweite Aufruf von ausgeben erfolgt mit dem Parameter zahl1, also wird param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels printf ausgeben.

Unterprogramme ohne Parameter Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, haben statt einer Parameterliste nur void stehen. Das void bedeutet "die Funktion erhält keine Parameter". "void main (void)" bedeutet also: "Erstelle ein Unterprogramm Namens main, das keinen Rückgabewert und keine Parameter hat".

Merke: Auch wenn eine Funktion keine Parameter hat, müssen Sie beim Aufruf trotzdem die Klammern angeben. Beispiel für eine parameterlose Funktion foo:

foo();

Prototypen

Wie oben erwähnt, kann ein Unterprogramm an jeder beliebigen Stelle im Programm stehen. Damit ist jedoch eine Bedingung verknüpft: Das Unterprogramm muß in der Datei oberhalb des ersten Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Deklaration davor erledigt haben. Verstanden? Um dies zu erreichen, gibt es zwei Möglichkeiten:

Entweder Sie schreiben alle Unterprogramme vor main in die Datei. Dies muß jedoch wiederum so geschehen, dass Funktionen zum Zeitpunkt ihres Aufrufes bereits bekannt sind! Wo dies nicht möglich ist (z.B. sich gegenseitig aufrufende Unterprogramme), oder wenn Sie das stört, müssen Sie Prototypen verwenden. Wie definiert man nun Prototypen? Sie kopieren einfach die erste Zeile des Unterprogrammes (z.B. "void ausgeben (int zahl)"), fügen einen Strichpunkt ;an und fügen es an einer geeigneten Stelle ein (so, dass alle Aufrufe später in der Datei kommen). Solche Definitionen stehen gewöhnlich am Anfang der Quelldatei oder in einer Header-Datei, die eingebunden wird.

#include <stdio.h>

void ausgeben (int zahl);  /* Der Prototyp */

int main (void)
{
   ausgeben (12);
   
   return 0;
}

void ausgeben (int zahl)   /* Die eigentliche Prozedur */
{
  printf ("Ausgabe: %d\n", zahl);
}

Parameterübergabe

Alle Werte, die an Prozeduren und Funktionen übergeben werden, werden grundsätzlich kopiert. Das hat folgende Auswirkungen:

Änderungen an einem Parameter in einer Funktion erscheinen nicht beim Aufrufer!
Möchte man, dass eine Funktion einen Wert trotzdem dauerhaft ändern soll, so muss die Adresse des Wertes via Zeiger übergeben werden.
Werden Strukturen übergeben, so wird von ihnen eine Kopie erstellt, was bei großen Strukturen viel Zeit und Arbeitsspeicher kostet. Deshalb wird häufig nur die Adresse von Strukturen übergeben, da die Adresse viel schneller und platzsparender als die Struktur selbst kopiert werden kann.

Beispiele:

void erhoehe (int x)
{
   x = x + 1;
}

int main (void)
{
   int a = 0;
   erhoehe(a);
   /* a ist immer noch 0 */ */
   
   return 0;
}

Beim Aufruf von erhoehe wird eine Kopie des Wertes von a (im Beispiel also 0) erstellt und der Prozedur als Parameter x übergeben. Weil dann die Prozedur erhoehe die Kopie verändert, hat dies keine Auswirkung auf das Original a im Hauptprogramm.

void erhoehe (int *x)
{
   /* erhoehe den Wert an der Adresse x um eins */
   *x = *x + 1;
}

int main(void)
{
   int a = 0;
   erhoehe (&a);
   /* a ist jetzt 1 */
   
   return 0;
}

Jetzt wird im Hauptprogramm mittels Adress-Operator & die Speicheradresse von a bestimmt. Dann wird eine Kopie der Adresse an das Unterprogramm erhoehe übergeben. Jetzt kennt das Unterprogramm die Adresse des Originals a und kann direkt mit dem Inhalts-Operator * auf den Wert an dieser Adresse zugreifen.

Besonderheit bei Feldern

Bei der Übergabe von Feldern gibt es eine Besonderheit. Schreibt man nämlich den Namen eines Feldes, so ist das nichts anderes als die Speicheradresse des ersten Elements. Bei der Übergabe eines Feldes wird also eine Kopie der Startadresse übergeben. Somit kann das Unterprogramm auf den Originaldaten arbeiten und diese verändern.

Beispiel:

void erhoehe (int x[])
{
   x[0] = x[0] + 1;
   x[1] = x[1] + 3;
   x[2] = x[2] + 5;
}

int main(int argc, char **argv)
{
  int a[] = {10, 20, 30};
  
  erhoehe (a);
  /* a hat jetzt folgenden Inhalte: 11, 23, 35 */
  
  return 0;
}

Dass die Übergabe einer Adresse erfolgt, sieht man an folgendem Beispiel, das von der Funktionsweise absolut identisch mit dem vorhergehenden ist:

/* Bei Parametern gibt es keinen Unterschied zwischen Zeiger und Feld */
void erhoehe (int *x)
{
   x[0] = x[0] + 1;
   x[1] = x[1] + 3;
   x[2] = x[2] + 5;
}

int main(int argc, char **argv)
{
   int a[] = {10, 20, 30};
  
   erhoehe (a);

   /* a hat jetzt folgenden Inhalt: 11, 23, 35 */
}

Die Länge des Feldes wird nicht automatisch übergeben. Dafür ist ggf. ein zusätzlicher Parameter notwendig.

Standard-Funktionen

strcpy

Bei vielen Compilern können sie einem String nicht direkt einen Wert (Text) zuweisen. Dazu müssen Sie dann die Prozedur strcpy() benutzen. Diese erwartet als ersten Parameter den Namen einer String-Variablen (ohne eckige Klammern) und als zweiten Parameter den eines (anderen) Strings. Letzterer kann auch ein in doppelten Hochkommas (") eingeschlossener Text sein. Die Funktion fügt am Ende automatisch ein 0-Zeichen ein. Um diese Funktion nutzen zu können, müssen Sie die Datei string.h includieren!

#include <stdio.h>
#include <string.h>

int main (void)
{
  char stri1[21], eingabe[21];

  strcpy (stri1, "hallo");

  printf ("Der 1. String: %s\n", stri1);
  printf ("Bitte geben Sie maximal 20 Zeichen ein: ");
  scanf  ("%s", eingabe);
  strcpy (stri1, eingabe);
  printf ("\n%s = %s", stri1, eingabe);
  
  return 0;
}

Hinweis: Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, dürfen Sie kein & bei scanf angeben!

Erklärung: Es werden zwei gleich große Strings definiert: stri1 und eingabe, mit je 20 "nutzbaren" Zeichen. In stri1 wird die Zeichenkette "hallo" hineinkopiert. Das 0-Zeichen am Ende wird automatisch angefügt. Der String wird ausgegeben. Als neues "Sonderzeichen" kommt %s ins Spiel. Es hat die gleiche Aufgabe wie %d oder %c, nur für Strings. Sie werden gebeten, eine String einzugeben. Dieser String wird danach in die Variable stri1 kopiert. Beide Strings, die ja nun die gleiche Zeichenkette enthalten, werden ausgegeben.

strlen

Die Funktion strlen, die als Parameter eine String-Variable erwartet, liefert die Länge diese Strings zurück. Sie werden jetzt vermutlich sagen: "Das ist doch klar, wie lang der String ist. Ich habe es ja bei der Deklaratin angegeben". Das stimmt schon, aber denken Sie noch einmal an die null-terminierten Strings. Das 0-Zeichen steht am Ende des Strings (am Ende der gültigen Zeichenfolge), aber nicht unbedingt am Ende des reservierten Speicherplatzes. Haben Sie eine Variable "char Variable[21];", und ihr den Wert "hallo" zugewiesen, dann steht das null-Zeichen in Variable[5]. Der "gültige" String ist also 5 Zeichen (0-4) lang. Und genau das (5) würde strlen zurück liefern.

#include <stdio.h>
#include <string.h>

int main (void)
{
  char stri[21];
  
  strcpy (stri, "hallo");
  printf ("Der String ist %d Zeichen lang", strlen (stri));
}

Diese Funktion wird vor allem gebraucht, wenn Sie direkt auf den String zugreifen, mittels stri[0], stri[1], etc.

Zeiger als Parameter

Wenn Sie ein Unterprogramm aufrufen, können Sie diesem Parameter übergeben, aber keine Werte zurückgekommen (außer den Funktionswert bei Funktionen). Dies hat einen guten Grund: beim Aufruf werden nicht die aufgerufenen Parameter benutzt, sondern es werden deren Werte in neue Variablen kopiert. Diese Variablen werden am Ende des Unterprogrammes "zerstört", ohne ihre Werte an die aufrufenden Parameter zu übergeben. Jede Veränderung eines Parameters hat daher keine Auswirkung auf den Parameter. Doch was ist, wenn Sie Parameter in Unterprogrammen verändern möchten? Ganz einfach, Sie verwenden Zeiger. Der Computer legt dann immer noch Kopien an. In dieser Kopie steht aber kein Wert, sondern die Adresse einer Varaiblen. Und auf diese können Sie dann zugreifen. Denken Sie nur an scanf - da übergeben Sie ja auch die Adresse einer Variablen ("&Variable").

#include <stdio.h>

void erhoehe (int *zeiger)
{
  *zeiger = *zeiger+1;
}

int main (void)
{
  int zahl;
  
  printf ("Zahl eingeben: ");
  scanf  ("%d", &zahl);
  erhoehe (&zahl);
  printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);
  
  return 0;
}

Parameter von `main`

Das Unterprogramm "main" kann, wie jede andere Funktion, Parameter besitzen. Doch keine selbst gewählten, sondern nur bestimmte. Doch warum braucht main Parameter? Denken Sie einmal an alle Betriebssystembefehle: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den main-Parametern abfragen.

int main (int argc, char *argv[], char* environ[])

Bei "argc" handelt es sich um eine normale int-Variable (engl. "argument count", "Parameter-Zähler"). In ihr steht die Anzahl der übergebenen Parameter. Die Parameter selbst folgen im zweiten Argument, das als Array von Strings übergeben wird. Das dritte Argument ist ein Array mit den Umgebungsvariablen. Seine Länge wird nicht explizit übergeben; nach dem letzten Element steht ein Null-String, also ein String der Länge 0. In dieser Array befindet sich auch der Inhalt der Umgebungsvariablen PATH, die den Suchpfad für ausführbare Programme enthält.

#include <stdio.h>
#include <stdlib.h>

int main (int argc, char *argv[], char * environ[])
{
  int i;

  printf ("Es wurden %d Parameter angegeben", argc);

  for (i=0; i < argc; i++) 
     printf ("Parameter %d: %s\n", i, argv[i]);

  for (i = 0; environ[i] != NULL; ++i) 
     printf ("environ[%d] = %s\n", i, environ[i]);
}

Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich argc[0]. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement – wie in C üblich – das Element <tt>argv[argc-1]. In der for-Schleife werden alle Parameter, inklusive ihrer Nummer, ausgegeben. Experimentieren Sie mit den Parametern, um das System zu vertehen!

Kurzreferenz

Syntax-Bausteine

Die Erklärung des Aufbaus von C-Befehlen erfolgt neben einfachen Beispielen auch durch ihren prinzipellen Aufbau. In diesen Syntax-Beschreibungen finden sich immer wieder die gleichen Bausteine, die hier näher erklärt werden werden. Falls die solch ein Syntax-Baustein begegnet, kannst du ihn anclicken und kommst dann zu seiner Erläuterung.

`<Bezeichner>`

Bezeichner in C dienen dazu, Variablen zu identifizieren und ihnen sprechende Namen zu geben, um die Quelle lesbarer zu machen. Man braucht Bezeichner auch, um selbst definierte Datentypen zu benennen und zum Benennen von Struct- und Union-Komponenten sowie als Namen für Funktionen und Sprungmarken (Labels).

Bezeichner dürfen aus den Kleinbuchstaben a...z, den Großbuchstaben A...Z, dem Unterstrich _ und den Ziffern 0...9 aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

`<Ausdruck>`

Ein Ausdruck in C ist ein Konstrukt, das einen Wert hat. Ob dieser Wert eine ganze Zahl ist, eine Kommazahl oder ein Zeiger, etc. ist dabei egal. Die einfachsten Ausdrücke sind Konstanten wie

oder Variablen wie

ein_zahl

Mehrere Ausdrücke können durch Operatoren zu komplexeren Ausdrücken kombiniert werden, etwa

eine_zahl + andere_zahl == 2

oder

eine_zahl = 2

Letzterer hat den Wert 2 und den Nebeneffekt, daß er diesen Wert an eine_zahl zuweist.

Auch der Aufruf einer Funktion, die einen Rückgabewert liefert, ist ein Ausdruck:

sin (1.2)

und kann zum Aufbau komplexerer Ausdrüche verwendet werden.

`<Bedingung>`

Eine Bedingung ist ein Ausdruck, bei der nur interessiert, ob dieser zu 0 (unwahr) auswertet oder zu ungleich 0 (wahr). Solche Ausdrücke findet man in if-Anweisungen, in Schleifenbedingungen und bedingten Zuweisungen

(ein_wert < 2) || (ein_wert > 40)

`<Lvalue>`

Ein Lvalue ist ein Ausdruck, dem etwas zugewiesen werden kann. Der Name Lvalue kommt aus dem Englischen. Das L steht abkürzend für left. Ein Lvalue ist damit ein Ausdruck, der auf der linken Seite eine Zuweisung in C stehen darf. Das x in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:

x = y-1

x++

`<Konstante>`

Eine Konstante ist ein Ausdruck, dessen Wert dem Compiler bekannt ist. Beispiele für Konstanten sind etwa

7
'B'
-13.98e12
1+(2*3)

und die Werte von enums.

Das Pi aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne

const double Pi = 3.14159256;

denn in einem anderen Quellmodul könnte Pi durch die Deklaration

extern const double Pi;

bekannt sein, ohne daß sein Wert bekannt ist!

`<Adresse>`

Eine Adresse ist ein Ausdruck, der einen Speicherort (physikalisch oder virtuell) halten kann. Adressen erhält man dadurch, daß man einem Bezeichner den Adress-Operator &voranstellt, Adressen durch Arithmetik berechnet oder Zahlen zu Adressen castet. Folgende Ausdrücke sind Adressen (eine sinnvolle Deklaration der auftretenden Variablen vorausgesetzt)

& eine_zahl
& ein_array[10]
& ein_struct
& ein_struct.komponente
(int *) 0x1234
(int *) eine_zahl

`<Deklaration>`

`<Anweisung>`

Anweisungen sind gewissermassen die Atome (oder Moleküle?), aus denen ein C-Programm besteht. Jedes C-Programm ist eine Abfolge von Deklarationen und Anweisungen. Einfache Anweisungen erhält man, in dem man einen Ausdruck nimmt und einen Strichpunkt dahinter schreibt:

<Ausdruck>;

wie in

x = x+1;

Andere Anweisungen sind die unten aufgeführten Schleifen und die if- sowie die switch-Anweisung.

Mehrere Deklarationen und Anweisungen können zu einem Block zusammengefasst werden. Dieser Block stellt dann wieder eine einzelne Anweisung dar und kann genau so gehandhabt werden!

{
   <Deklaration>
   <Deklaration>
   ...
   <Anweisung>
   <Anweisung>
   ...
}

In diesem Sinne ist auch z.B. die Syntax der if-Anweisung zu verstehen

if (<Bedingung>)
   <Anweisung>

besagt, daß der abhängig ausgeführte Code eine einzelne Anweisung sein darf oder eben ein kompletter Block oder die Verschachtelung mehrerer Blöcke etc.

Eine Anweisung kann auch "leer" sein, also nichts tun. Diese Anweisungen sind der leere Block

{
}

und der Strichpunkt

die man gelegentlich in Schleifen findet:

while (!timeout())
   {}

oder hinter Sprungmarken, die sonst direkt vor einer schliessenden Blockklammer stünden:

{
   ...
   goto ein_label;
   ...
   ein_label:;
}

Nicht jede Anweisung ist an jeder Stelle eines C-Programms erlaubt, so darf ein continue nut innerhalb einer Schleife stehen. Gleiches gilt für break, das aber auch innerhalb eines switch vorkommen darf.

if

if (<Bedingung>)
   <Anweisung>

if-else

if (<Bedingung>)
   <Anweisung>
else
   <Anweisung>

for

for (<Ausdruck1>; <Bedingung>; <Ausdruck2>)
   <Anweisung>

Eine for-Schleife entspricht folgendem Konstrukt. Dabei sind die drei Ausdrücke optional. Fehlt die Bedingung, dann wird diese als "wahr" angenommen. Die beiden anderen Ausdrücke wird man als Ausdrücke mit Nebeneffekt wählen wie z.B. x=0 oder x=x-2.

{
   <Ausdruck1>;

   _loop:
   if (<Bedingung>)
      <Anweisung>
   else
      goto _break;

   _continue:
   <Ausdruck2>;
   goto _loop;

   _break:;
}

Die Labels _break und _continue entsprechen den Sprungzielen einer break bzw. continue-Anweisung innerhalb von <Anweisung>.

do-while

do
   <Anweisung>
while  (<Bedingung>);

while

while  (<Bedingung>)
   <Anweisung>

switch

switch  (<Bedingung>)
{
   case <Konstante>:
      <Anweisung>
      <Anweisung>
      ...

   default:
      <Anweisung>
      <Anweisung>
      ...
}

Liste der Schlüsselworte

auto
break
double
char
case
const
continue
default
do
else
enum
extern
float
for
goto
if
int
long
return
register
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while

Baustelle

Liste der Operatoren

Operator	Bedeutung
Arithmetische Operatoren
Dies sind die "normalen" arithmetischen Operationen, wie man sie aus der Schule kennt. Man kann damit und allen anderen Operatoren auch komplexere Ausdrücke aufbauen. Die Prioritäten sind so, wie man sie kennt, also "Punktrechnung vor Strichrechnung". Will man dies ändern, dann mit den runden Klammern: `1+23` → 7 `(1+2)3` → 9
`<Ausdruck> + <Ausdruck>`	Addition
`<Ausdruck> - <Ausdruck>`	Subtraktion
`<Ausdruck> * <Ausdruck>`	Multiplikation
`<Ausdruck> / <Ausdruck>`	Division
`<Ausdruck> % <Ausdruck>`	Rest der Division (modulo)
`- <Ausdruck>`	Vorzeichenumkehr, Zweier-Komplement
Logische Operatoren und Vergleiche
Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert `0` (wahr) oder einen Wert ungleich `0` (falsch, um genau zu sein den Wert `!0`). Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu `if` oder in Abbruch-Bedingungen von Schleifen finden.
`<Ausdruck> && <Ausdruck>`	logisches AND: beides wahr (ungleich 0)
`<Ausdruck> \|\| <Ausdruck>`	logisches OR: mind. eines ist wahr (ungleich 0)
`! <Ausdruck>`	logisches NOT (0 ↔ ungleich 0)
`<Ausdruck> == <Ausdruck>`	ist gleich
`<Ausdruck> != <Ausdruck>`	ist nicht gleich
`<Ausdruck> < <Ausdruck>`	ist kleiner
`<Ausdruck> <= <Ausdruck>`	ist kleiner oder gleich
`<Ausdruck> > <Ausdruck>`	ist größer
`<Ausdruck> >= <Ausdruck>`	ist größer oder gleich
Bitweise Operatoren
`~ <Ausdruck>`	bitweise NOT (Einser-Komplement)
`<Ausdruck> & <Ausdruck>`	bitweise AND
`<Ausdruck> \| <Ausdruck>`	bitweise ODER
`<Ausdruck> ^ <Ausdruck>`	bitweise XOR
Shift-Operatoren
`<Ausdruck> << <Ausdruck>`	Bits nach links schieben
`<Ausdruck> >> <Ausdruck>`	Schieben nach rechts schieben
Typumwandlung
Ein Cast in C kann dazu verwendet werden, den Typ eines Ausdruckes zu ändern oder den Ausdruck mit einer bestimmten Genauigkeit zu berechnen. Wird z.B. eine Berechnung standardmässig in 16 Bit ausgeführt, dann kann man mit einem Cast `(long) ···` ausdrücken, daß die Berechnung in 32 Bit erfolgen soll. Des weiteren kann man Zeiger und ganze Zahlen und Gleitkommazahlen ineinander umwandeln. Casts können nicht dazu verwendet werden, um z.B. eine Zahl in einen String zu konvertieren, der diese Zahl darstellt! Dafür gibt es spezielle Funktionen wie `itoa`!
`(<Type>) <Ausdruck>`	Cast, Typwandlung
Zeiger und Adressen
`* <Adresse>`	der Inhalt an Adresse
`& <Lvalue>`	Adresse von
Strukturen, Unions, Arrays
`<Struct>.<Bezeichner>`	Komponente einer Struktur/Union
`<Zeiger-auf-Struct> -> <Bezeichner>`	Komponente einer Struktur/Union, deren Adresse man hat
`<Adresse>[<Ausdruck>]`	Array-Element
Bedingte Auswertung
`(<Bedingung>) ? <Ausdruck> : <Ausdruck>`	Auswahl des Wertes abhängig von der Bedingung
Zuweisung und Operatoren mit Nebeneffekt
Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie `x = p++` zum tragen: `x = p++;` → `x = p; p = p+1;` `x = ++p;` → `p = p+1; x = p;` `x = (p)++;` → `x = p; p = (p)+1;` `x = ++(p);` → `p = (p)+1; x = *p;`
`<Lvalue> = <Ausdruck>`	Zuweisung
`++ <Lvalue>`	Pre-Increment
`-- <Lvalue>`	Pre-Decrement
`<Lvalue> ++`	Post-Increment
`<Lvalue> --`	Post-Decrement
Kurzschreibweisen
Für ganz Faule gibt es anstatt `a = a @ b` für viele Operatoren (hier dargestellt durch ein `@`) die abkürzende Schreibweise `a @= b`
`<Lvalue> += <Ausdruck>`
`<Lvalue> -= <Ausdruck>`
`<Lvalue> *= <Ausdruck>`
`<Lvalue> /= <Ausdruck>`
`<Lvalue> %= <Ausdruck>`
`<Lvalue> ^= <Ausdruck>`
`<Lvalue> &= <Ausdruck>`
`<Lvalue> \| <Ausdruck>`
`<Lvalue> <<= <Ausdruck>`
`<Lvalue> >>= <Ausdruck>`

Autoren

Plasma
Bernd
SprinterSB

Quellen:

Kernighan und Ritchie - Buch
Christian Wirth , C Tutorial
Prof. Dr. J. Dankert Ausführungen

Siehe auch

Weblinks

C-Tutorial

Inhaltsverzeichnis

Geschichte

Aufbau eines C-Programmes

Das Hauptprogramm main

Blöcke

Datentypen

Elementare Datentypen

int, char, short, long (ganze Zahlen)

Boolean (Logische Variablen)

char (Zeichen)

float, double (Gleitkommazahlen)

void

Zeiger

Enum

Zusammengesetzte Datentypen

Arrays

Strings (Zeichenketten)

Mehrdimensionale Arrays

Strukturen

Unions

Eigene Datentypen

Variablen

Variablennamen

Anlegen von Variablen

Zuweisungen

Zuweisungen bei float

Zuweisungen bei logischen Variablen

Konstanten

Gültigkeitsbereich

Speicherklassen

Ausdrücke

Lvalues

Logische (boolsche) Operatoren

Vergleich von Variablen

Arithmetische Operatoren

Bit-Operatoren

Index-Operator bei Arrays

Komponenten-Auswahl bei Structs und Unions

Adress-Operator und Dereferenzierung

Cast-Operator

Komma-Operator

Zuweisungen und Operatoren mit Nebeneffekt

Bedingter Ausdruck

Reihenfolge der Auswertung

Boolsche Logik

Kontrollanweisungen

if-Anweisung

switch-Anweisung

Schleifen

while-Schleife

do-while-Schleife

for-Schleife

Ein- und Ausgabe

Bildschirm-Ausgabe

Tastatur-Eingabe

Allgemeines zu Unterprogrammen

Funktionen

Prozedur

Prototypen

Parameterübergabe

Standard-Funktionen

strcpy

strlen

Zeiger als Parameter

Parameter von main

Kurzreferenz

Syntax-Bausteine

<Bezeichner>

<Ausdruck>

<Bedingung>

<Lvalue>

<Konstante>

<Adresse>

<Deklaration>

<Anweisung>

if

if-else

for

do-while

Parameter von `main`

`<Bezeichner>`

`<Ausdruck>`

`<Bedingung>`

`<Lvalue>`

`<Konstante>`

`<Adresse>`

`<Deklaration>`

`<Anweisung>`