RN-Wissen.de - Benutzerbeiträge [de]

C-Tutorial

2007-04-09T21:37:26Z

Inrfb2: /* <tt><Parameterliste></tt> */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|Zugriff auf Struktur-Komponenten}}
hubert.alter = 32;
klaus.alter = hubert.alter + 1;

'''Hinweis:'''
Der eventuell etwas lästige Gebrauch von <tt>struct</tt> kann schon bei der Definition der Struktur vermieden werden.
Der Definition ist ein <tt>typedef</tt> voranzustellen. Der Definition folgt dann ein gültiger (und auch eindeutiger) C-Name.

'''Syntax:'''
typedef struct {{Bezeichner}}
{
{{Deklaration}}
{{Deklaration}}
...
} {{Bezeichner}} ;

'''Beispiel:'''
{{comment|Definition der Struktur '_Mensch' bzw. 'Mensch'}}
struct _Mensch
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
} Mensch;

Jetzt sind folgende Deklarationen identisch:
struct _Mensch {{Bezeichner}};
Mensch {{Bezeichner}};

Ist der Struktuname nicht notwendig (im Beispiel oben <tt>_Mensch</tt>), kann auch kürzer geschrieben werden:

'''Syntax:'''
typedef struct
{
{{Deklaration}}
{{Deklaration}}
...
} {{Bezeichner}} ;

'''Beispiel:'''
{{comment|Definition der Struktur 'Mensch'}}
struct
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
} Mensch;

In diesem Fall ist lediglich die {{Deklaration}} <tt>Mensch {{Bezeichner}};</tt> gültig.

Der Hinweis gilt sinngemäß auch für die Definition <tt>union</tt> im nachfolgenden Abschnitt.

===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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Sicher jedoch ist, dass nicht jeder Programmierer diese Regel jederzeit im Kopf hat.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

Die Reihenfolge der Auswertung von Funktionsargumenten ist in der ANSI-Spezifikation nicht angegeben und daher compilerabhängig. Von Konstrukten wie
{
int i=0;
func (i++, i++);
}
ist also dringend abzuraten!

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

;Ein Hinweis am Rande: Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang. Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen. Siehe auch [[#Zeiger auf Funktionen|Zeiger auf Funktionen]].

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Inlining==

In C gibt es die Möglichkeit, eine Funktion als ''inline''-Funktion zu definieren.
Für eine inline-Funktion wird üblicher Weise kein Code erzeugt, der beim Aufruf der Funktion angesprungen wird, sondern an der Stelle des Aufrufs wird eine Kopie der inline-Funktion eingefügt.

Vom Effekt her ist eine inline-Funktion also ähnlich wie ein Makro. Allerdings wird das Einfügen des Codes nicht vom Präprozessor übernommen, sondern vom eigentlichen C-Compiler. Damit der Compiler in der Lage ist, eine Funktion zu inlinen, muss ihm der Code zur Verfügung stehen, da er ansonsten natürlich keinen Code einfügen kann.

Das Schlüsselwort ist ''inline'':
{{ccomment|Deklariere ''increment'' als inline-Funktion}}
static inline int increment (int);

{{ccomment|Implementierung von ''increment''}}
int increment (int i)
{
return i+1;
}

{{ccomment|Aufruf von ''increment'' wie eine normale Funktion}}
int foo (int n)
{
if (n < MAX_INT)
n = increment (n);

return n;
}

Inline-Funktionen werden verwendet, wenn der Funktionscode recht klein ist und ein Funktionsaufruf schon so aufwändig ist wie das, was die Funktion zu erledigen hat. Im Beispiel wird der gleiche Code erzeugt, wie wenn <tt>n = n + 1</tt> im Aufrufer stünde, was deutlich schneller ist als ein Funktionsaufruf mit Register-Sicherung, Parameterübergabe, Wertrückgabe, etc.

==Variable Argumentanzahl==

'''Baustelle'''

<pre>
#include <stdarg.h>

static void uput_va (const char * fmt, va_list args /*, uint8_t pstr_p*/)
{
while (1)
{
char c = (pstr_p)
? pgm_read_byte (fmt++)
: *fmt++;

if ('\0' == c)
return;

if ('%' == c)
{
c = (pstr_p)
? pgm_read_byte (fmt++)
: *fmt++;

if ('%' == c) putc (c);
if ('c' == c) putc (va_arg (args, int));

if ('s' == c) { fn = uputs ; ; goto _dispatch; }
continue;
}

if ('\n' == c)
putc ('\r');

putc (c);
}
}
</pre>
void uput_PSTR (const char * fmt, ...)
{
va_list vlist;
va_start (vlist, fmt);
uput_va (fmt, vlist);
va_end (vlist);
}

== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert eine Variable als Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. 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]</tt>. 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 sollen. Falls Dir solch ein Syntax-Baustein begegnet, kannst Du ihn anklicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparameterige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, verwendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#Inlining|<tt>inline</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

= Autoren=
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

=Quellen=
* Kernighan und Ritchie
* Christian Wirth, C-Tutorial
* Prof. Dr. J. Dankert Ausführungen
* W. Alex, Einführung in C/C++
* Peter Baeumle-Courth, ANSI-C im Überblick

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

C-Tutorial

2007-04-09T21:36:40Z

Inrfb2: /* <tt><Parameterliste></tt> */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|Zugriff auf Struktur-Komponenten}}
hubert.alter = 32;
klaus.alter = hubert.alter + 1;

'''Hinweis:'''
Der eventuell etwas lästige Gebrauch von <tt>struct</tt> kann schon bei der Definition der Struktur vermieden werden.
Der Definition ist ein <tt>typedef</tt> voranzustellen. Der Definition folgt dann ein gültiger (und auch eindeutiger) C-Name.

'''Syntax:'''
typedef struct {{Bezeichner}}
{
{{Deklaration}}
{{Deklaration}}
...
} {{Bezeichner}} ;

'''Beispiel:'''
{{comment|Definition der Struktur '_Mensch' bzw. 'Mensch'}}
struct _Mensch
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
} Mensch;

Jetzt sind folgende Deklarationen identisch:
struct _Mensch {{Bezeichner}};
Mensch {{Bezeichner}};

Ist der Struktuname nicht notwendig (im Beispiel oben <tt>_Mensch</tt>), kann auch kürzer geschrieben werden:

'''Syntax:'''
typedef struct
{
{{Deklaration}}
{{Deklaration}}
...
} {{Bezeichner}} ;

'''Beispiel:'''
{{comment|Definition der Struktur 'Mensch'}}
struct
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
} Mensch;

In diesem Fall ist lediglich die {{Deklaration}} <tt>Mensch {{Bezeichner}};</tt> gültig.

Der Hinweis gilt sinngemäß auch für die Definition <tt>union</tt> im nachfolgenden Abschnitt.

===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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Sicher jedoch ist, dass nicht jeder Programmierer diese Regel jederzeit im Kopf hat.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

Die Reihenfolge der Auswertung von Funktionsargumenten ist in der ANSI-Spezifikation nicht angegeben und daher compilerabhängig. Von Konstrukten wie
{
int i=0;
func (i++, i++);
}
ist also dringend abzuraten!

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

;Ein Hinweis am Rande: Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang. Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen. Siehe auch [[#Zeiger auf Funktionen|Zeiger auf Funktionen]].

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Inlining==

In C gibt es die Möglichkeit, eine Funktion als ''inline''-Funktion zu definieren.
Für eine inline-Funktion wird üblicher Weise kein Code erzeugt, der beim Aufruf der Funktion angesprungen wird, sondern an der Stelle des Aufrufs wird eine Kopie der inline-Funktion eingefügt.

Vom Effekt her ist eine inline-Funktion also ähnlich wie ein Makro. Allerdings wird das Einfügen des Codes nicht vom Präprozessor übernommen, sondern vom eigentlichen C-Compiler. Damit der Compiler in der Lage ist, eine Funktion zu inlinen, muss ihm der Code zur Verfügung stehen, da er ansonsten natürlich keinen Code einfügen kann.

Das Schlüsselwort ist ''inline'':
{{ccomment|Deklariere ''increment'' als inline-Funktion}}
static inline int increment (int);

{{ccomment|Implementierung von ''increment''}}
int increment (int i)
{
return i+1;
}

{{ccomment|Aufruf von ''increment'' wie eine normale Funktion}}
int foo (int n)
{
if (n < MAX_INT)
n = increment (n);

return n;
}

Inline-Funktionen werden verwendet, wenn der Funktionscode recht klein ist und ein Funktionsaufruf schon so aufwändig ist wie das, was die Funktion zu erledigen hat. Im Beispiel wird der gleiche Code erzeugt, wie wenn <tt>n = n + 1</tt> im Aufrufer stünde, was deutlich schneller ist als ein Funktionsaufruf mit Register-Sicherung, Parameterübergabe, Wertrückgabe, etc.

==Variable Argumentanzahl==

'''Baustelle'''

<pre>
#include <stdarg.h>

static void uput_va (const char * fmt, va_list args /*, uint8_t pstr_p*/)
{
while (1)
{
char c = (pstr_p)
? pgm_read_byte (fmt++)
: *fmt++;

if ('\0' == c)
return;

if ('%' == c)
{
c = (pstr_p)
? pgm_read_byte (fmt++)
: *fmt++;

if ('%' == c) putc (c);
if ('c' == c) putc (va_arg (args, int));

if ('s' == c) { fn = uputs ; ; goto _dispatch; }
continue;
}

if ('\n' == c)
putc ('\r');

putc (c);
}
}
</pre>
void uput_PSTR (const char * fmt, ...)
{
va_list vlist;
va_start (vlist, fmt);
uput_va (fmt, vlist);
va_end (vlist);
}

== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert eine Variable als Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. 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]</tt>. 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 sollen. Falls Dir solch ein Syntax-Baustein begegnet, kannst Du ihn anklicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, verwendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#Inlining|<tt>inline</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

= Autoren=
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

=Quellen=
* Kernighan und Ritchie
* Christian Wirth, C-Tutorial
* Prof. Dr. J. Dankert Ausführungen
* W. Alex, Einführung in C/C++
* Peter Baeumle-Courth, ANSI-C im Überblick

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

Avr-gcc

2007-03-20T10:58:18Z

Inrfb2: /* Zugiff auf Bytes und Worte */

'''avr-gcc''' ist ein freier C-[[Compiler]], mit dem man C-Programme zu ausführbaren Programmen übersetzen kann, die auf [[Microcontroller]]n der [[AVR]]-Familie lauffähig sind.
An Sprachen versteht avr-gcc sowohl C als auch [[#C%2b%2b|C++]].
Neben Standard-C bzw. ANSI-C versteht avr-gcc auch GNU-C, das etwas mehr Möglichkeiten und kleinere Spracherweiterungen bietet.

avr-gcc kann auch dazu verwendet werden, um C/C++ Programme nach Assembler zu übersetzen oder um Bibliotheken zu erstellen, die später in unterschiedlichen Projekten verwendet werden können.

Wie bei allen aus der UNIX-Welt kommenden Programmen ist das Kommando-Interface von avr-gcc die Shell bzw. die Kommandozeile, über die Optionen, Parameter, Einstellungen und die Namen der zu übersetzenden Dateien angegeben werden.

=How to Read=

Dieser Artikel bespricht avr-gcc Version 3.x. Er ist kein C-Tutorial und kein AVR-Handbuch – das würde den Umfang des Artikels bei weitem sprengen.

Der Artikel ist ein Handbuch zu avr-gcc. Er bespricht zum Beispiel, wie man avr-gcc anwendet und Besonderheiten von avr-gcc-C,
die nicht zum Sprachumfang von C gehören.
Dazu zählen die Definition von [[#Interrupts|Interrupt]] Service Routinen ([[ISR|ISRs]])
oder wie man Daten ins [[EEPROM]] legt.

Es wird also besprochen, ''wie'' eine ISR zu definieren ist, aber nicht,
''warum'' das gegebenenfalls notwendig oder nicht notwendig ist.
''Warum'' etwas gemacht wird, ist abhängig von der gestellten Aufgabe,
etwa ''"Initialisiere den [[UART]] zur Benutzung mit 9600 Baud"''.
Dafür enthält dieser Artikel zusammen mit dem AVR-Handbuch das Rüstzeug,
bietet aber keine Lösungen für konkrete Aufgaben.

Neben diesem Artikel gibt es den Unterartikel [[avr-gcc/Interna|Interna von avr-gcc]] wo Dinge wie die Registerverwendung, Attribute, Builtins und Sections von avr-gcc dargestellt werden. Zudem findet sich dort ein Überblick über die Arbeitsweise von gcc mit den Schritten
* Precompilieren
* Compilieren
* Assemblieren
* Linken
Ein weiterer Unterartikel widmet sich dem Thema [[Inline-Assembler in avr-gcc]].

In den [[:Kategorie:Quellcode C|C-Codebeispielen]]
befindet sich das ausführlichere Beispiel "[[Hallo Welt für AVR (LED blinken)]]",
das nur eine [[Diode#Lumineszenzdiode|LED]] blinkt und zeigt,
wie ein kleines Projekt mit avr-gcc compiliert werden kann.

Es gibt ein [[C-Tutorial]], das jedoch noch unvollständig und teilweise feherhaft ist (Stand 02/2006). Darüber hinaus gibt es ein [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial C-Tutorial bei www.mikrocontroller.net].

=Benutzer-Schnittstelle=

Die Benutzer-Schnittstelle von avr-gcc ist – wie für alle Programme, die aus der UNIX-Welt kommen – die Kommandozeile einer Shell, Console bzw. Eingabeaufforderung.

Im einfachsten Fall sieht ein Aufruf von avr-gcc also so aus:
> avr-gcc
Dabei das '<tt>></tt>' nicht mittippen, und ein ENTER am Ende der Zeile drücken.
Die Antwort bei korrekter Installation ist dann
avr-gcc: no input files
Was bedeutet: das Programm avr-gcc wurde vom Betriebssystem gefunden und konnte/durfte gestartet werden. Dann gibt avr-gcc eine Fehlermeldung aus und beendet die Ausführung, weil er keine Eingabedatei(en) bekommen hat was ja auch stimmt. Soweit ist also alles in Butter.

Um eine C-Datei <tt>foo.c</tt> mir avr-gcc optimiert zu einem lauffähigen elf-Programm <tt>foo.elf</tt> für einen [[ATmega32]] zu compileren, würde man angeben
> avr-gcc -O2 -mmcu=atmega32 foo.c -o foo.elf
Hat man seine Quellen auf zwei oder mehre Dateien verteilt, geht es analog:
> avr-gcc -O2 -mmcu=atmega32 foo.c foo2.c -o foo.elf

Will man nur eine Objekt-Datei erstellen (nur compilieren, nicht linken), dann geht das wie folgt. Das kann günstig sein bei grösseren Projekten, wenn man das Projekt neu erzeugen will, aber nur in einer Quelldatei was geändert hat. Oder wenn das Objekt in einer Bibliothek landen soll.
> avr-gcc -O2 -c -mmcu=atmega32 foo.c -o foo.o

Die ausführbare Gesamtdatei <tt>foo_all.elf</tt> erhält man dann, indem alle Objekte zusammenlinkt:
> avr-gcc -mmcu=atmega32 foo.o foo2.o foo3.o -o foo_all.elf

Um die ausführbare Datei in das oft verwendete Intex-HEX-Format umzuwandeln (einmal fürs Programm, einmal für ein Abbild des [[EEPROM]]s) gibt man an:
> avr-objcopy -O ihex -j .text -j .data foo_all.elf foo_all.hex
> avr-objcopy -O ihex -j .eeprom --change-section-lma .eeprom=0 foo_all.elf foo_all_eeprom.hex

----

[[GCC]] war immer Kommandozeilen-orientiert und wird es auch immer bleiben, denn das hat gute Gründe:
* ein Compiler ist ein Compiler ist ein Compiler (und keine grafische Bedienschnittstelle)
* die Plattformabhängigkeit wird auf ein Minimum reduziert
* es gibt die Möglichkeit, avr-gcc per Skript oder [[make]] zu starten
* avr-gcc kann durchaus in eine Umgebung integriert werden: in einen Editor oder in eine GUI wie neuere Versionen von AVR-Studio erfolgreich beweisen, etc. Der avr-gcc-Aufruf kann sogar von einem Server-Socket oder einer Web-Application heraus erfolgen, welche ein C-Programm empfängt, es von avr-gcc übersetzen lässt, und das Resultat zurückschickt oder sonst was damit anstellt.
* Lizenzgründe: eine Umgebung, die avr-gcc integriert, kann durchaus proprietär oder nicht quelloffen sein und muss nicht der [[Freie Software|GPL]] unterliegen. Wieder ist AVR-Studio ein Beispiel.

= Unterstützte AVR-Derivate=
;Classic AVR:: [[AT90S1200]], [[AT90S2313]], [[AT90S8515]], [[AT90S8535]], [[AT90S4433]], [[AT90S4414]], [[AT90S4434]], [[AT90S2323]], [[AT90S2333]], [[AT90S2343]],

;tinyAVR:: [[ATtiny10]], [[ATtiny11]], [[ATtiny12]], [[ATtiny15]], [[ATtiny28]], [[ATtiny22]], [[ATtiny26]], [[AT90C8534]], [[AT86rf401]], [[ATtiny13]], [[ATtiny2313]], [[ATtiny261]], [[ATtiny461]], [[ATtiny861]], [[ATtiny24]], [[ATtiny44]], [[ATtiny84]], [[ATtiny25]], [[ATtiny45]], [[ATtiny85]]

;megaAVR:: [[ATmega603]], [[ATmega103]], [[AT76C711]], [[ATmega48]], [[ATmega8]], [[ATmega83]], [[ATmega85]], [[ATmega88]], [[ATmega8515]], [[ATmega8535]], [[ATmega16]], [[ATmega161]], [[ATmega162]], [[ATmega163]], [[ATmega164p]], [[ATmega165]], [[ATmega165P]], [[ATmega168]], [[ATmega32]], [[ATmega323]], [[ATmega324P]], [[ATmega325]], [[ATmega3250]], [[ATmega64]], [[ATmega640]], [[ATmega644]], [[ATmega644P]], [[ATmega128]], [[ATmega1280]], [[ATmega1281]], [[ATmega645]], [[ATmega6450]], [[AT94K]]

; [[LCD]] AVR:: [[ATmega169]], [[ATmega169P]], [[ATmega329]], [[ATmega3290]], [[ATmega649]], [[ATmega6490]],
; Lightning AVR:: [[AT90PWM2]], [[AT90PWM3]]
; [[CAN]] AVR:: [[AT90CAN32]], [[AT90CAN64]], [[AT90CAN128]]
; Smart Battery:: [[ATmega406]]
; [[USB]] AVR:: [[AT43USB320]], [[AT43USB355]], [[AT90USB646]], [[AT90USB647]], [[AT90USB1286]], [[AT90USB1287]]
;

Diese Liste kann man avr-gcc anzeigen lassen mit
> avr-gcc --target-help

=Kommandozeilen-Optionen=
Die Codegenerierung bei avr-gcc wird über Kommandozeilen-Optionen gesteuert. Diese legen fest, für welchen Controller Code zu erzeugen ist, wie stark optimiert wird, ob Debug-Informationen erzeugt werden, etc. Die Optionen teilen sich in zwei Gruppen: Optionen, die für alle GCC-Ports verfürgbar sind und maschinenspezifische Optionen, die nur für AVR verfügbar sind.

Aus der Masse an GCC-Optionen kann hier nur ein kleiner Auszug der wichtigsten und am häufigsten verwendeten Optionen vorgestellt werden. Eine Auflistung aller GCC-Optionen mit Kurzbeschreibung umfasst knapp 1000 Zeilen ohne undokumentierte Optionen, versteht sich.

==Allgemeine Optionen für GCC==
; <tt>--help</tt>: Anzeige der wichtigsten Optionen
; <tt>--help -v</tt>: Überschüttet einen mit Optionen
; <tt>--target-help</tt>: Anzeige der wichtigsten maschinenspezifischen Optionen und der unterstützten AVR-Derivate
; <tt>-O0</tt>: keine Optimierung
; <tt>-O1</tt>: Optimierung
; <tt>-Os</tt>: optimiert für Code-Größe
; <tt>-O2</tt>: stärkere Optimierung für bessere Laufzeit
; <tt>-g</tt>: erzeugt Debug-Informationen
; <tt>-c</tt>: (pre)compilert und assembliert nur bis zum Objekt (<tt>*.o</tt>), kein Link-Lauf
; <tt>-S</tt>: (pre)compilert nur und erzeugt Assembler-Ausgabe (*.s)
; <tt>-E</tt>: nur Precompilat (<tt>*.i</tt>) erzeugen, kein Compilieren, kein Assemblieren, kein Linken
; <tt>-o <filename></tt>: legt den Name der Ausgabedatei fest
; <tt>-v</tt>: zeigt Versionsinformationen an und ist geschwätzig (verbose): Anzeige der aufgerufenen tools
; <tt>-I<path></tt>: Angabe eines weiteren Include-Pfads, in dem Dateien mit <tt>#include <...></tt> gesucht werden
; <tt>-E -dM <filename></tt>: Anzeige aller Defines
; <tt>-MM</tt>: Für die angegebenen Eingabe-Dateien wird eine Ausgabe erzeugt, die als [[make|Makefile]]-Fragment dienen kann und die Anhängigkeiten (dependencies) der Objekte von den Quellen/Headern beschreibt.
; <tt>-D<name></tt>: Definiert Makro <tt><name></tt>
; <tt>-D<name>=<wert></tt>: Definiert Makro <tt><name></tt> zu <tt><wert></tt>
; <tt>-U<name></tt>: Undefiniert Makro <tt><name></tt>
; <tt>-save-temps</tt>: Temporäre Dateien (<tt>*.i</tt>, <tt>*.s</tt>) werden nicht gelöscht. Teilweise fehlerhaft zusammen mit <tt>-c</tt>
; <tt>-Wa,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Assembler (<tt>avr-as</tt>)
:;<tt>-Wa,-a=<filename></tt>: Assembler erzeugt ein Listing mit Name <tt><filename></tt>
; <tt>-Wp,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Preprozessor
; <tt>-Wl,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Linker (<tt>avr-ld</tt>)
:;<tt>-Wl,-Map=<filename></tt>: Linker erzeugt ein Map-File mit Name <tt><filename></tt>
:;<tt>-Wl,--oformat=<format></tt>: Linker erzeugt Ausgabe im Format <tt><format></tt>, z.b. <tt>ihex</tt> für Intel-HEX-File
:;<tt>-Wl,--section-start=<section>=<address></tt>: Linker legt die [[avr-gcc/Interna#Sections|Section]] <tt><section></tt> ab Adresse <tt><address></tt>, z.B: <tt>.eeprom=0x810001</tt>
; <tt>-Wall</tt>: gibt mehr Warnungen, aber immer noch nicht alle
; <tt>-pedantic</tt>: geht besonders pedantisch mit Code um
; <tt>-std=c89 -ansi</tt>: bricht mit einer Fehlermeldung ab, wenn kein ANSI-C (ISO C89) verwendet wurde
; <tt>-std=c99</tt>: bricht mit einer Fehlermeldung ab, wenn kein ISO C99 verwendet wurde
; <tt>-ffreestanding</tt>: Das erzeugte Programm läuft nicht in einer Umgebung wie einer Shell. Der Prototyp von <tt>main</tt> ist
:<pre>void main (void);</pre>

==Maschinenspezifische Optionen für avr-gcc==
Maschinenabhängige Optionen beginnen immer mit '''-m'''
;-mmcu=xxx: Festlegen des Targets (Zielsystem/Controller), für das Code generiert werden soll. Je nach Target muss avr-gcc unterschiedliche Instruktionen verwenden und andere Startup-Dateien (<tt>crtxxx.o</tt>) einbinden. avr-gcc setzt spezielle Defines, um auch in der Quelle zwischen den Targets unterscheiden zu können, falls das notwendig sein sollte:
:{| border="0" cellpadding="0" cellspacing="0"
|
<pre>
#ifdef __AVR_AT90S2313__
/* Code fuer AT90S2313 */
#elif defined (__AVR_ATmega8__) || defined (__AVR_ATmega32__)
/* Code fuer Mega8 und Mega32 */
#else
#error Das ist noch nicht implementiert für diesen Controller!
#endif
</pre>
|}

Zwar gibt es für alle AVR-Derivate die <tt>avr/io.h</tt>, aber die AVR-Familien unterscheiden sich in ihrer Hardware; z.B. darin, wie I/O-Register heissen oder wie Hardware zu initialisieren ist. Diese Abhängigkeit kann man in unterschiedlichen Codestücken aufteilen und wie oben gezeigt bedingt übersetzen. Dadurch hat man Funktionalitäten wie <tt>uart_init</tt> auf unterschiedlichen Controllern und wahrt den Überblick, weil nicht für jede Controller-Familie eine extra Datei notwendig ist.
{|
|- valign="top"
|
:{| {{Blauetabelle}}
|+ '''AVR classic, <= 8 kByte'''
|- {{Hintergrund1}}
!|mcu || Builtin define
|-
|avr2 ||<tt>__AVR_ARCH__=2</tt>
|-
|[[AT90S2313|at90s2313]] ||<tt>__AVR_AT90S2313__</tt>
|-
|at90s2323 ||<tt>__AVR_AT90S2323__</tt>
|-
|at90s2333 ||<tt>__AVR_AT90S2333__</tt>
|-
|at90s2343 ||<tt>__AVR_AT90S2343__</tt>
|-
|attiny22 ||<tt>__AVR_ATtiny22__</tt>
|-
|attiny26 ||<tt>__AVR_ATtiny26__</tt>
|-
|at90s4414 ||<tt>__AVR_AT90S4414__</tt>
|-
|at90s4433 ||<tt>__AVR_AT90S4433__</tt>
|-
|at90s4434 ||<tt>__AVR_AT90S4434__</tt>
|-
|at90s8515 ||<tt>__AVR_AT90S8515__</tt>
|-
|at90c8534 ||<tt>__AVR_AT90C8534__</tt>
|-
|at90s8535 ||<tt>__AVR_AT90S8535__</tt>
|-
|at86rf401 ||<tt>__AVR_AT86RF401__</tt>
|}
| 
:{| {{Blauetabelle}}
|+ '''AVR classic, > 8 kByte'''
|- bgcolor="#ccccff"
! |mcu ||Builtin define
|-
|avr3 ||<tt>__AVR_ARCH__=3</tt>
|-
|atmega103 ||<tt>__AVR_ATmega103__</tt>
|-
|atmega603 ||<tt>__AVR_ATmega603__</tt>
|-
|at43usb320 ||<tt>__AVR_AT43USB320__</tt>
|-
|at43usb355 ||<tt>__AVR_AT43USB355__</tt>
|-
|at76c711 ||<tt>__AVR_AT76C711__</tt>
|}
|}

----

{|
|- valign="top"
|
:{| {{Blauetabelle}}
|+ '''AVR enhanced, <= 8 kByte'''
|- bgcolor="#ccccff"
!|mcu || Builtin define
|-
|avr4 ||<tt>__AVR_ARCH__=4</tt>
|-
|[[Atmel Controller Mega8|atmega8]] ||<tt>__AVR_ATmega8__</tt>
|-
|atmega8515 ||<tt>__AVR_ATmega8515__</tt>
|-
|atmega8535 ||<tt>__AVR_ATmega8535__</tt>
|}
|
:{| {{Blauetabelle}}
|+ '''AVR enhanced, > 8 kByte'''
|- bgcolor="#ccccff"
!|mcu ||Builtin define
|-
|avr5 ||<tt>__AVR_ARCH__=5</tt>
|-
|[[Atmel Controller Mega16 und Mega32|atmega16]] ||<tt>__AVR_ATmega16__</tt>
|-
|atmega161 ||<tt>__AVR_ATmega161__</tt>
|-
|atmega162 ||<tt>__AVR_ATmega162__</tt>
|-
|atmega163 ||<tt>__AVR_ATmega163__</tt>
|-
|atmega169 ||<tt>__AVR_ATmega169__</tt>
|-
|[[Atmel Controller Mega16 und Mega32|atmega32]] ||<tt>__AVR_ATmega32__</tt>
|-
|atmega323 ||<tt>__AVR_ATmega323__</tt>
|-
|[[ATMega64|atmega64]] ||<tt>__AVR_ATmega64__</tt>
|-
|[[Atmel Controller Mega128|atmega128]] ||<tt>__AVR_ATmega128__</tt>
|-
|at94k ||<tt>__AVR_AT94K__</tt>
|}
|}

----

:{| {{Blauetabelle}}
|+ '''AVR, nur Assembler'''
|- bgcolor="#ccccff"
! |mcu ||Builtin define
|-
|avr1 ||<tt>__AVR_ARCH__=1</tt>
|-
|at90s1200 ||<tt>__AVR_AT90S1200__</tt>
|-
|attiny11 ||<tt>__AVR_ATtiny11__</tt>
|-
|attiny12 ||<tt>__AVR_ATtiny12__</tt>
|-
|attiny15 ||<tt>__AVR_ATtiny15__</tt>
|-
|attiny28 ||<tt>__AVR_ATtiny28__</tt>
|}

----

; -minit-stack=xxx: Festlegen der Stack-Adresse
; -mint8: Datentyp <tt>int</tt> ist nur 8 Bit breit, anstatt 16 Bit. Datentypen mit 32 Bit wie <tt>long</tt> sind nicht verfügbar
; -mno-interrupts: Ändert den Stackpointer ohne Interrupts zu deaktivieren
; -mcall-prologues: Funktions-Prolog und -Epilog werden als Unterroutinen umgesetzt, um die Codegröße zu verkleinern
; -mtiny-stack: Nur die unteren 8 Bit des Stackpointers werden verändert
; -mno-tablejump: Für ein <tt>switch</tt>-Statement werden keine Sprungtabellen angelegt
; -mshort-calls: Verwendet <tt>rjmp</tt>/<tt>rcall</tt> (begrenzte Sprungweite) auf Devices mit mehr als 8 kByte Flash
; -msize: Ausgabe der Instruktonslängen im asm-File
; -mdeb: (undokumentiert) Ausgabe von Debug-Informationen für GCC-Entwickler
; -morder1: (undokumentiert) andere Register-Allokierung
; -morder2: (undokumentiert) andere Register-Allokierung

=C++=

:''"C++ is a complex language and an evolving one, and its standard definition (the ISO C++ standard) was only recently completed. As a result, your C++ compiler may occasionally surprise you, even when its behavior is correct."''

Zudem sollte der Einsatz von C++ aus Effizienzgründen sehr kritisch betrachtet werden:
:''"When programming C++ in space- and runtime-sensitive environments like microcontrollers, extra care should be taken to avoid unwanted side effects of the C++ calling conventions like implied copy constructors that could be called upon function invocation etc. These things could easily add up into a considerable amount of time and program memory wasted. Thus, casual inspection of the generated assembler code (using the <tt>-S</tt> compiler option) seems to be warranted."''

Weiterhin unterliegt der Einsatz von C++ je nach Compiler/Lib-Version bestimmten Einschränkungen:
*Einer kompletten C++ Implementierung fehlt die Unterstützung durch die <tt>libstdc++</tt>, dadurch fehlen Standardfunktionen, -Klassen und -Templates
* Die Operatoren <tt>new</tt> und <tt>delete</tt> sind nicht implementiert, ihre Verwendung führt zu unauflösbaren externen Referenzen (Linker-Fehler)
*Nicht alle Header sind C++-sicher und müssen in <tt>extern "C" {...}</tt> eingeschlossen werden.
*Exceptions werden nicht unterstützt und müssen via <tt>-fno-exceptions</tt> abgeschaltet werden, oder der Linker beschwert sich über eine unauflösbare externe Referenz zu <tt>__gxx_personality_sj0</tt>.

Als Treiber verwendet man wie immer avr-gcc. Standard-Endungen für C++ sind <tt>.c++</tt> und <tt>.cpp</tt>. Bei anderen Endungen teilt man mit <tt>-x c++</tt> mit, daß es sich um C++ Dateien handelt, oder ruft <tt>avr-c++</tt> direkt auf.

Interrupt-Service-Routinen (ISRs) sind C-Funktionen und werden definiert wie gehabt. Siehe auch [[#Interrupts|Interrupts]].
#include <avr/io.h>
#include <avr/interrupt.h>

#if defined (__cplusplus)
extern "C" {
#endif {{comment|__cplusplus}}

SIGNAL (SIG_NAME)
{
{{comment|machwas}}
}

INTERRUPT (SIG_NAME)
{
{{comment|mach was}}
}

#if defined (__cplusplus)
}
#endif {{comment|__cplusplus}}
<tt>__cplusplus</tt> ist ein Standard [[avr-gcc/Interna#Builtin Defines|GCC-Builtin-Define]].

Globale Konstruktoren werden in [[avr-gcc/Interna#Sections|Section]] <tt>.init6</tt> ausgeführt, die Destruktoren in <tt>.fini6</tt>.

=Code-Beispiele=
Dieser Abschnitt enthält Code-Schnippsel für avr-gcc. Es werden Besonderheiten besprochen, die für avr-gcc zu beachten sind.

Dieser Abschnitt ist ''kein'' [[C-Tutorial|Tutorial zur C-Programmierung]] und ''keine'' Einführung in die Programmiersprache C im allgemeinen. Dafür sei auf einschlägige Tutorials/Bücher verwiesen.

==Zugriff auf Special Function Registers (SFRs)==

===Zugiff auf Bytes und Worte===
Vor dem Zugriff auf die SFRs gibt es Defines über den Include
#include <avr/io.h>
Abhängig vom eingestellten Controller werden denn Defines eingebunden, über die auf SFRs wie auf normale Variablen zugegriffen werden kann. Die Namen der Defines sind i.d.R. die gleichen wie im AVR-Manual, also z.b. <tt>SREG</tt> für das Prozessorstatus-Register SREG:
#include <avr/io.h>

...
{{ccomment|SREG lesen}}
uint8_t sreg = SREG;
...
{{ccomment|SREG schreiben}}
SREG = sreg;

Für einen Überblick über die eingebundenen Defines und kann ein Blick in den Controller-spezifischen Header hilfreich sein. Dieser befindet sich in
:<tt> <GCC_HOME>/avr/include/avr/io****.h</tt>
z.B. <tt>iom32.h</tt> für einen [[ATmega32]].

Dieser Zugriff geht auch für 16-Bit Register wie <tt>TCNT1</tt>, für die eine bestimmte Reihenfolge für den Zugriff auf Low- und High-Teil eingehalten werden muss: avr-gcc generiert die Zugriffe in der richtigen Reihenfolge.
uint16_t tcnt1 = TCNT1;

{{FarbigerRahmen|
Zu beachten ist, daß dieser Zugriff nicht atomar erfolgt. Das Lesen/Schreiben mehrbytiger Werte muss vom Compiler in mehrere Byte-Zugriffe zerlegt werden. Zwischen diesen Zugriffen kann ein [[Interrupt]] auftreten, wenn Interrupts aktiviert sind. Je nach Programm und welche Aufgaben eine [[ISR]] erledigt, kann dies zu Fehlfunktion führen. In dem Fall müssen diese Code-Stücke atomar gemacht werden, damit sie nicht durch einen [[IRQ]] unterbrochen werden können!
}}

===Zugriff auf einzelne Bits===
Zugriff auf Bits geht wie gewohnt mit den Bitoperationen
<tt>&</tt> (and),
<tt>|</tt> (or),
<tt>^</tt> (xor) und
<tt>~</tt> (not)

Wieder gibt es Defines in den AVR-Headern, mit denen man Masken für den Zugriff erhalten kann, etwa:
<pre>
/* GIMSK / GICR */
#define INT1 7
#define INT0 6
#define IVSEL 1
#define IVCE 0
</pre>

Masken ergeben sich durch Schieben von <tt>1</tt> an die richtige Position:
<pre>
// Ports B_0 und B_1 als Ausgang
DDRB |= (1<<PB0) | (1<<PB1);
</pre>
erzeugt
<pre>
87 b3 in r24, 0x17
83 60 ori r24, 0x03
87 bb out 0x17, r24
</pre>

Etwas anders sieht der Code aus, wenn die Bits einzeln gesetzt werden und das Register im bitadressierbaren Bereich liegt (SRAM <tt>0x20</tt> bis <tt>0x3f</tt> resp. I/O <tt>0x0</tt> bis <tt>0x1f</tt>):
<pre>
// Ports B_0 und B_1 als Ausgang
DDRB |= (1<<PB0);
DDRB |= (1<<PB1);
</pre>
erzeugt
<pre>
b8 9a sbi 0x17, 0
b9 9a sbi 0x17, 1
</pre>

Um Bits zu löschen, erzeugt man eine Maske, die an der betreffenden Stelle eine  0 hat:
<pre>
// Ports B_2 als Eingang
DDRB &= ~(1<<PB2);
</pre>

{{FarbigerRahmen|
Auch hier ist zu beachten, daß es Probleme geben kann, wenn nicht atomarer Code erzeugt wird, weil der AVR-Befehlssatz nicht mehr hergibt:
<pre>
// toggle PORT B_0: wechseln 0 <--> 1
PORTB ^= (1<<PB0);
</pre>
ergibt
<pre>
88 b3 in r24, 0x18
; Wenn hier ein Interrupt auftritt, in dessen ISR PORTB verändert wird,
; dann wird die Änderung durch die letzte Instruktion wieder überschrieben!
91 e0 ldi r25, 0x01
; dito
89 27 eor r24, r25
; dito
88 bb out 0x18, r24
</pre>
}} 

Auch das Lesen einzelner Port-Pins geht über das Maskieren von SFRs:
<pre>
DDRB &= ~(1 << PB2); // PortB.2 als INPUT

if (PINB & (1 << PB2))
// PortB.2 ist HIGH
else
// PortB.2 ist LOW

if (!(PINB & (1 << PB2)))
// PortB.2 ist LOW
else
// PortB.2 ist HIGH
</pre>

==Interrupts==

Um zu kennzeichnen, daß es sich bei einer Funktion um eine Interrupt Sevice Routine (ISR) handelt, gibt es spezielle Attribute. Diese brauchen nicht explizit hingeschrieben zu werden, ebensowenig wie die genaue Nummer des Interrupt Requests (IRQ). Dafür gibt es Includes und die folgenden Makros.

Bitte beachte auch die Hinweise zu den [[#Inkompatibilität|Inkompatibilität]]en von avr-gcc!
#include <avr/io.h>
#include <avr/interrupt.h>

{{ccomment|Eine nichtunterbrechbare Interrupt-Service-Routine}}
SIGNAL (SIG_OUTPUT_COMPARE1A)
{
{{ccomment|ISR-Code}}
}

{{ccomment|Eine unterbrechbare Interrupt-Service-Routine}}
INTERRUPT (SIG_OUTPUT_COMPARE1B)
{
{{ccomment|ISR-Code}}
}

Dadurch wird die Funktion mit dem richtigen Prolog/Epilog erzeugt, und es wird ein Eintrag in die Interrupt-Vektortabelle gemacht bei obigem Beispiel also zwei Einträge.

{{FarbigerRahmen|
Die Schreibweise des Signal-Names muss genau die sein wie im Header, das schliesst auch Leerzeichen ein! Nicht alle GCC-Versionen bringen Fehler/Warnung, wenn die Schreibweise nicht stimmt.
SIGNAL (SIG_OUTPUT_COMPARE1A ) // !!! Macht NICHT das, was man will (Blank am Ende)!!!
}}

;<tt>SIGNAL</tt>: Mit Ausführung einer ISR deaktiviert die AVR-Hardware die Interrupts, so daß die ISR nicht durch andere Interrupt-Anforderungen unterbrochen wird. Beim Verlassen der ISR werden Interrupts wieder automatisch aktiviert. Tritt während der ISR ein IRQ auf, wird diese erst nach Beenden des ISR-Codes ausgeführt. Der Interrupt geht also nicht verloren. Zwischen zwei ISRs wird zusätzlich mindestens ein Befehl des normalen Programm-Codes abgearbeitet.
;<tt>INTERRUPT</tt>: Früh im ISR-Prolog werden mit <tt>sei</tt> die von der AVR-Hardware temporär deaktivierten Interrupts reaktiviert. Dadurch kann die ISR von einer IRQ unterbrochen werden. Das bietet die Möglichkeit, so etwas wie Interrupt-Priorisierung nachzubilden, was AVRs selbst nicht können. Weiterhin kann man schneller auf bestimmte Ereignisse reagieren. Tritt während der ISR ein anderer IRQ auf, der schnell bedient werden muss, kann sofort der dringende ISR-Code ausgeführt werden. Ansonsten (Verwendung von <tt>SIGNAL</tt>) würde der Code erst ausgeführt werden, nachdem die aktuelle ISR beendet ist.

{{FarbigerRahmen|Dauert die ISR zu lange und wird sie nochmals von ihrem eigenen IRQ unterbrochen, stürzt man ab.}}

Nachschlagen kann man den Namen in
:<tt><GCC_HOME>/avr/include/avr/ioxxxx.h</tt>

===Interrupts aktivieren===

Damit eine ISR überhaupt zur Ausführung kommt, müssen drei Bedingungen erfüllt sein
* Interrupts müssen global aktiviert sein
* Der entsprechen IRQ muss aktiviert worden sein
* Das zum IRQ gehörende Ereignis muss eintreten
#include <avr/io.h>
#include <avr/interrupt.h>

...
{{ccomment|enable OutputCompareA Interrupt für Timer1}}
TIMSK |= (1 << OCIE1A);

{{ccomment|disable OutputCompareA Interrupt für Timer1}}
TIMSK &= ~(1 << OCIE1A);

{{ccomment|Interrupts aktivieren}}
sei();

{{ccomment|Interrupts abschalten}}
cli();
Sperrt man eine Code-Sequenz durch Einschachteln in ein <tt>cli</tt>/<tt>sei</tt> Paar (man macht das Codestück "atomar", also ununterbrechbar), gehen währenddessen keine Interrupt-Anforderungen verloren. Die entsprechenden IRQ-Flags bleiben gesetzt, und nach dem <tt>sei</tt> werden die IRQs in der Reihenfolge ihrer Prioritäten abgearbeitet. Ausnahme ist, wenn in einem atomaren Block der selbe IRQ mehrfach auftritt. Der ISR-Code wird dann trotzdem nur einmal ausgeführt.

===default Interrupt===

Für nicht implementierte Interrupts macht avr-gcc in die Vektortabelle einen Eintrag,
der zu <tt>__bad_interrupt</tt> (definiert im Startup-Code <tt>crt*.o</tt>) springt
und von dort aus weiter zu Adresse 0.
Dadurch läuft der AVR wieder von neuem los, wenn ein Interrupt auftritt,
zu dem man keine ISR definiert hat
 allerdings ohne die Hardware zurückzusetzen wie bei einem echten Reset.

Möchte man diesen Fall abfangen, dann geht das über eine globale Funktion
namens <tt>__vector_default</tt>:
<pre>
#include <avr/interrupt.h>

SIGNAL (__vector_default)
...
</pre>
Damit wird von <tt>__bad_interrupt</tt> aus nicht nach Adresse 0 gesprungen,
sondern weiter zu <tt>__vector_default</tt>, welches durch <tt>SIGNAL</tt> oder
<tt>INTERRUPT</tt> den üblichen ISR-Prolog/Epilog bekommt.

So kann man z.B. eine Meldung ausgeben, eine Warnlampe blinken, in einer Endlosschleife landen, oder über den [[Watchdog]] einen richtigen Hardware-Reset auslösen, siehe auch Abschnitt "[[#Reset auslösen|Reset auslösen]]".

===ISR mit eigenem Prolog/Epilog===

Wenn man in einer ISR komplett eigenes Zeug machen will,
dann definiert man eine nackte Funktion.
Mit <tt>naked</tt> befreit man die Routine vom Standard-Prolog/Epilog.
{{FarbigerRahmen|
Dabei ist darauf zu achten, daß die ISR mit <tt>reti</tt> (return from interrupt)
zurückkehrt und evtl. verwendete Register und den Status (<tt>SREG</tt>) sichert.
}}
#include <avr/io.h>

void __attribute__ ((naked))
SIG_OVERFLOW0 (void)
{
{{ccomment|Port B.6 = 0}}
{{ccomment|Diese Instruktion verändert nicht das SREG und kein anderes Register}}
{{ccomment|so daß der eigentliche Code nur 1 Befehl lang ist}}
__asm__ __volatile (
"cbi %0, %1" "\n\t"
"reti"
:
: "M" (_SFR_IO_ADDR (PORTB)), "i" (6)
);
}

Siehe auch [[Inline-Assembler in avr-gcc]].
Die ISR sieht dann so aus:
<pre>
__vector_9:
c6 98 cbi 0x18, 6
18 95 reti
</pre>

Wiederum kann man als Funktionsname <tt>__vector_default</tt> nehmen,
um nicht-implementierte IRQs abzufangen:
<pre>
void __attribute__ ((naked))
__vector_default (void)
...
</pre>

==SRAM, Flash, EEPROM: Datenablage am Beispiel Strings==
Die Programmiersprache C kennt selber keine Strings; das einzige, was C bekannt ist, ist der Datentyp <tt>char</tt>, der ein einzelnes Zeichen repräsentiert.
===Darstellung in C===
Ein String im Sinne von C ist ein Array von Charactern bzw. ein Zeiger auf den Anfang des Arrays. Die einzelnen Zeichen folgen im Speicher direkt aufeinander und werden in aufsteigenden Adressen gespeichert. Am String-Ende folgt als Abschluss der Character <tt>'\0'</tt>, um das Ende zu kennzeichnen. Dies ist besonders bei der Berechnung des Speicherplatzes für Strings zu berücksichtigen, denn für die 0 muss auch Platz reserviert werden.

===Bestimmen der Stringlänge===
<pre>
/* Bestimmt die Laenge des Strings ohne die abschliessende '\0' zu zaehlen */
unsigned int strlength (const char *str)
{
unsigned int len = 0;

while (*str++)
len++;

return len;
}
</pre>

Die Stringlänge kann auch mit der Standard-Funktion <tt>strlen</tt> bestimmt werden, deren Prototyp sich in <tt>string.h</tt> befindet:
<pre>
#include <string.h>
size_t strlen (const char*);
</pre>

===String im Flash belassen===
Oftmals werden Strings nur zu Ausgabezwecken verwendet und nicht verändert. Verwendet man Sequenzen der Gestalt
<pre>
char *str1 = "Hallo Welt!";
char str2[] = "Hallo Welt!";
</pre>
dann werden die Strings im SRAM abgelegt. Im Startup-Code werden die Strings vom Flash ins SRAM kopiert und belegen daher sowohl Platz im SRAM als auch im Flash. Wird ein String nicht verändert, braucht er nicht ins SRAM kopiert zu werden. Das spart Platz im knapp bemessenen SRAM. Allerdings muss anders auf den String zugegriffen werden, denn wegen der Harvard-Architektur des AVR-Kerns kann avr-gcc anhand der Adresse nicht unterscheiden, ob diese ins SRAM, ins Flash oder ins EEPROM zeigt.
<pre>
#include <avr/pgmspace.h>

const prog_char str3[] = "Hallo Welt!";

unsigned int strlen_P (const prog_char *str)
{
unsigned int len = 0;

while (1)
{
char c = (char) pgm_read_byte (str);
if ('\0' == c)
return len;
len++;
str++;
}
}

void foo()
{
unsigned int len;
len = strlen_P (str3);
len = strlen_P (PSTR("String im Flash"));
}
</pre>

===String ins EEPROM legen===
Dies geht nach dem gleichen Muster, nach dem Strings ins Flash gelegt werden. Der Zugriff wird vergleichsweise langsam, denn der EEPROM ist langsamer als SRAM bzw. Flash.
<pre>
#include <avr/eeprom.h>

const char str4[] __attribute__ ((section(".eeprom"))) = "Hallo Welt!";

unsigned int strlen_EE (const char *str)
{
unsigned int len = 0;

while (1)
{
char c = (char) eeprom_read_byte (str);
if ('\0' == c)
return len;
len++;
str++;
}
}
</pre>

==Reset auslösen==
Falls ein Reset per Software ausgelöst werden soll, dann geht das am besten über den [[Watchdog]].
Einfach nur an den RESET-Punkt an Adresse 0 zu springen mit
goto *((void**) 0);
initialisiert zwar den Controller von neuem, aber es macht keinen wirkliches RESET mit Zurücksetzen der Hardware und allen I/O-Registern.

Durch den Watchdog kann man ein 'richtiges' RESET-Signal erzeugen lassen, so daß die AVR-Hardware genau so initialisiert ist, wie nach einem externen RESET. So kann man z.B. via [[UART]] ein RESET-Kommando schicken. Allerdings lässt sich der Watchdog nur minimal auf 15ms einstellen:

#include <avr/wdt.h>
#include <avr/interrupt.h>
...
cli(); {{ccomment|Interrupts global abschalten}}
wdt_enable (WDTO_15MS); {{ccomment|Watchdog aufziehen auf 15ms}}
while (1); {{ccomment|warten, bis er zubeisst...}}

Welches Ereignis einen RESET ausgelöst hat, kann man im Register '''MCUCSR''' (''MCU Control and Status Register'') erfahren. Es gibt 4 mögliche RESET-Quellen:
* Power-On Reset
* External Reset
* Brown-Out Reset
* Watchdog Reset

Soll der Inhalt von Variablen einen Reset überleben – eine Variable also nicht initialisiert werden – dann geht das so:
#include <avr/io.h>

{{ccomment| status informiert z.B. darüber, ob wir selber den Watchdog ausgelöst haben }}
{{ccomment| oder nicht, oder andere Informationen }}
unsigned char status __attribute__ ((section (".noinit")));

void main (void)
{
{{ccomment|Wert von MCUSCR merken, möglichst früh im Programm }}
unsigned char mcucsr = MCUCSR;

{{ccomment|MCUCSR zurücksetzen }}
MCUCSR = 0;

{{ccomment|Watchdog-Reset }}
if (mcuscr & (1 << WDRF))
{
{{ccomment|status auswerten }}
}

{{ccomment|Power-On Reset: status auf definierten Wert setzen }}
if (mcuscr & (1 << PORF))
{
status = 0;
}

{{ccomment|status auswerten }}
...
}

=Includes=

Die mit
#include <...>
angegebenen Includes werden von avr-gcc in den
mit der Option '<tt>-I</tt>' anegegenen Pfaden gesucht.
Dem Compiler bekannt sind die Pfade
<GCC_HOME>/avr/include Standard (stdio.h, ...)
<GCC_HOME>/avr/include/avr AVR-spezifisch (avr/io.h, ...)
<GCC_HOME>/lib/gcc/avr/<GCC_VERSION>/include Standard, compilerabh. (limits.h, ...)

Gibt man z.B. an
#include <stdio.h>
dann wird automatisch in diesem Verzeichnis nach <tt>stdio.h</tt> gesucht.
In den Verzeichnissen stehen Standard-Includes, die benötigt werden, wenn man libc-Funktionen
oder mathematische Funktionen etc. verwendet.
AVR-spezifische Dinge stehen im Unterverzeichnis <tt>avr</tt>, etwa:
#include <avr/io.h>
{{FarbigerRahmen|
Als Pfad-Separator wird immer ein '''<tt>/</tt>''' verwendet, auch auf Windows-Betriebssystemen! Also kein '''<tt>\</tt>''' !
}}

==Standard==

ctype.h Zeichen-Umwandlungs-Makros und ctype Makros
errno.h Symbolische Namen für Fehlercodes
inttypes.h Definiert [u]intN_t wenn man genau N [un]signed Bits
braucht, ISO C99.
math.h Mathematische Funktionen: sin, cos, log, gamma, bessel, ...
setjmp.h libc unterstützt setjmp() und longjmp(), um direkt in eine
andere (nicht-lokale) Funktion zu springen.
stdio.h Standard I/O-Funktionen (printf, ...).
stdlib.h Deklariert grundlegende ISO C-Makros und -Funktionen
sowie einige AVR-spezifische Erweiterungen
string.h Stringoperationen auf NULL-terminierten Strings. (strlen, ...)
stdarg.h Funktionen mit variabler Argumenanzahl
limits.h Min- und Max-Werte von Skalaren (UCHAR_MAX, LONG_MIN, ...)

==AVR-spezifisch==

Die AVR-spezifischen Includes finden sich wie gesagt im Unterverzeichnis <tt>avr</tt>.
Die meisten dort befindlichen Header wird man nie direkt durch Angabe im C-File erhalten,
sondern durch Angabe von
#include <avr/io.h>
Dadurch werden z.B. genau die I/O-Header eingebunden, die zum AVR-Modell passen, also
*<tt>avr/iom8.h</tt> für [[ATmega8]],
*<tt>avr/iotn2313.h</tt> für [[ATtiny2313]],
*<tt>avr/io2313.h</tt> für [[AT90S2313]], etc.

Verantwortlich dafür ist der Schalter '<tt>-mmcu=xxx</tt>'.

Obwohl diese Header nicht explizit angegeben werden müssen,
kann ein Blick dorthin hilfreich sein, um die Namen von [[SFR|SFRs]]
oder Signals nachzuschlagen.
Diese Header werden im folgenden nicht alle einzeln aufgelistet.
Ihre Namen sind immer <tt>avr/io*.h</tt>.
* für ATmega: <tt>avr/iom*.h</tt>
* für ATtiny: <tt>avr/iotn*.h</tt>
<pre>
avr/boot.h Bootloader Support
avr/crc16.h [*] Prüfsumme CRC16
avr/delay.h [*] Verzögerungsschleifen für kurze, exakte Verzögerungen
avr/eeprom.h EEPROM-Routinen
avr/ina90.h Kompatibilität mit IAR-AVR-Compiler
avr/interrupt.h sei(), cli(), ...
avr/io.h --> inttypes.h, io*.h
avr/io*.h SFRs, SIG_****, SPM_PAGESIZE, RAMEND, XRAMEND, E2END, FLASHEND
avr/parity.h [*] Parität
avr/pgmspace.h Zugriff aufs Flash: Byte lesen, PROGMEM, prog_char, prog_uint8_t, ...
avr/portpins.h Makros für Port-Pins
avr/signal.h [**] Makros SIGNAL() und INTERRUPT(), ...
avr/sleep.h Power-Safe
avr/twi.h [*] I2C
avr/wdt.h Watchdog

util/crc16.h Prüfsumme CRC16
util/delay.h Verzögerungsschleifen für kurze, exakte Verzögerungen
util/parity.h Parität
util/twi.h I2C

[*] bei neueren avr-gcc-Versionen in util
[**] entfällt bei neueren avr-gcc-Versionen. Stattdessen avr/interrupt.h verwenden
</pre>

==Anwendungs-spezifisch==
Eigene Header, die nur innerhalb eigener Projekte gebraucht werden, includet man mit
#include "..."
Auch hier darf man Unterverzeichnisse angeben oder ins übergeordnete Verzeichnis:
#include "../../mein-zeug.h"

=Optimierungen, Tipps & Tricks=

Beim Programmieren in C möchte man sich möglichst wenig mit der Codeerzeugung selbst auseinandersetzen. Man verwendet ja gerade deshalb einen Compiler und programmiert nicht in Assembler, weil man sich nicht um Register-Belegungen o.ä. kümmern will, sondern nur um die zu lösende Aufgabe.

GCC erzeugt zwar recht guten Code, aber er ist nicht perfekt. Gerade auf Systemen wie AVR mit nur sehr begrenzten Resourcen muss man daher dem Compiler hilfreich zur Seite stehen, wenn man noch dichteren/schnelleren Code erhalten möchte.

:''"Unlike most other C compilers, GCC allows you to use -g with -O. The shortcuts taken by optimized code may occasionally produce surprising results: some variables you declared may not exist at all; flow of control may briefly move where you did not expect it; some statements may not be executed because they compute constant results or their values were already at hand; some statements may execute in different places because they were moved out of loops.''

:''Nevertheless it proves possible to debug optimized output. This makes it reasonable to use the optimizer for programs that might have bugs."''

Um das Ergebnis zu beurteilen, hilft ein Blick ins Listfile.
Siehe dazu auch die Abschnitte
"[[Hallo Welt für AVR (LED blinken)#Listfile erstellen|Listfile erstellen]]"
und
"[[Hallo Welt für AVR (LED blinken)#Die Größe ermitteln|Die Größe ermitteln]]"
im [[Hallo Welt für AVR (LED blinken)|Hallo Welt für AVR]].

==Optimierungsgrad==
Als Optimierungsgrad erweist sich <tt>-Os</tt> (Optimize for Size) als der beste, evtl. noch <tt>-O2</tt>. Ohne Angabe eines Optimierungsgrades wird nicht optimiert, was gleichbedeutend mit der Option <tt>-O0</tt> ist. Abzuraten ist von der maximalen Optimierung <tt>-O3</tt>, die wegen function inlining und loop unrolling zu sehr breitem Code führt und für AVR absolut nicht angesagt ist.

==Vermeide printf, scanf, malloc==
Funktionen von diesem Kaliber sind die absoluten Platz- und Zeitfresser.

Alternativen findet man reichlich in der <tt>avr-libc</tt> wie <tt>itoa</tt> und <tt>atoi</tt>.
Und für <tt>malloc</tt> und Konsorten sind dynamische Arrays und das Compiler-Builtin <tt>__builtin_alloca</tt> effizientere Alternativen, siehe auch im Abschnitt "[[avr-gcc#Dynamische Speicherallokierung|Dynamische Speicherallokierung]]".

==Konstante Strings ins Flash==
Konstante Strings, wie sie zu Ausgabezwecken Verwendung finden, werden im Programm oft nicht verändert und brauchen nicht SRAM zu belegen (und damit auch Flash, von wo aus sie vom Startup-Code ins SRAM kopiert werden), sondern gehören ins Flash!

Entsprechende Routinen, um auf Strings im Flash zuzugreifen, tragen die Suffix <tt>_P</tt>, wie z.B. <tt>strcmp_P</tt> mit dem Prototyp
extern int *strcmp_P (char *, const prog_char *)
Die Implementierungen befinden sich in der <tt>avr-libc</tt>.

'''Anwendung:'''
#include <avr/pgmspace.h>

const prog_char str_p[] = "Ein String im Flash";
const char str2_p[] PROGMEM = "Noch ein String im Flash";
...
{{ccomment|String im SRAM mit String im Flash vergleichen}}
if (!strcmp_P (str_sram, str_p))
{
{{ccomment|mach was bei Gleichheit}}
}

{{ccomment|"foo" wird im RAM angelegt. Ineffizient für konstante Strings!}}
{{ccomment|Beachte, daß damit strcmp (nicht strcmp_P) benutzt werden muss.}}
if (!strcmp (str_sram, "foo"))
{
{{ccomment|mach was bei Gleichheit}}
}

{{ccomment|PSTR bewirkt, daß die String-Konstante "foo"}}
{{ccomment|im Flash angelegt wird}}
if (!strcmp_P (str_sram, PSTR ("foo"))
{
{{ccomment|mach was bei Gleichheit}}
}
...
}

===Sprungtabelle===
Genauso macht man auch eine Sprungtabelle, um anhand von Kommando-Strings dazugehörige Funktionen ausführen zu lassen:
#include <avr/pgmspace.h>

int func1 (int arg)
{
...
}

#define TEXT_LEN 15

{{ccomment|Die Kommandostruktur}}
typedef struct
{
int (*func)(int); {{ccomment|Zeiger auf die auszuführende Funktion}}
int arg; {{ccomment|das Argument, das mitübergeben wird}}
char text[1+TEXT_LEN]; {{ccomment|Text, maximal TEXT_LEN Zeichen lang}}
} command_t;

{{ccomment|Das Array mit den Kommandos.}}
{{ccomment|Die funcx sind vom Prototyp (z.B. func1 oben)}}
{{ccomment|int funcx (int arg);}}
const command_t commands[] PROGMEM =
{
{ func1, 0, "Befehl 1" },
{ func2, 3, "Befehl für func2" }
};

{{ccomment|Sucht in commands[] nach text und führt gegebenenfalls}}
{{ccomment|die dazugehörige Funktion funcx mit Argument arg aus.}}
{{ccomment|Liefert den Rückgabewert von funcx}}
{{ccomment|oder -1, falls text nicht gefunden wurde.}}
int execute (const char *text)
{
{{ccomment|Schleifenvariable}}
unsigned char i;

{{ccomment|Wandert durch das Array mit Kommando-Strukturen}}
const command_t * cmd = commands;

{{ccomment|sizeof wird von gcc ausgewertet und ist wie eine Konstante,}}
{{ccomment|denn beide sizeofs sind zur Compilezeit bekannt}}
for (i=0; i < sizeof(commands) / sizeof(command_t); i++)
{
{{ccomment|Ist das der gesuchte String?}}
if (strcmp_P (text, cmd->text))
{
{{ccomment|Nein, dann weitersuchen}}
cmd++;
continue;
}

{{ccomment|Ja}}
int (*func)(int), arg;

{{ccomment|Dann Funktionszeiger und Argument besorgen,}}
func = (int(*)(int)) pgm_read_word (& cmd->func);
arg = (int) pgm_read_word (& cmd->arg);

{{ccomment|Funktion ausführen und deren Wert zurückliefern}}
return func (arg);
}

{{ccomment|text ist nicht in commands}}
return -1;
}

Nachteil dabei ist, daß jeder String den maximalen Platz von <tt>TEXT_LEN+1</tt> Zeichen belegt.
Falls man da noch weiter sparen will, dann kann man die Strings wieder ins Flash legen und ihre Adresse in der Struktur merken. Dadurch belegt ein String nur noch Länge+3 Zeichen (+3 wegen 1 Endezeichen und 2 Bytes für seine in der Struktur gemerkte Adresse). Die Definition der Tabelle wird aber umständlicher, weil jeder String einzeln angegeben werden muss:
#include <avr/pgmspace.h>

{{ccomment|Die Kommandostruktur}}
typedef struct
{
...
char * text; {{ccomment|Zeiger auf Text}}
} command_t;

const prog_char str_1[] = "Befehl 1";
const prog_char str_2[] = "Befehl für func2";

const command_t commands[] PROGMEM =
{
{ func1, 0, str_1 },
{ func2, 3, str_2 }
};

{{ccomment|Sucht in commands[] nach text und führt gegebenenfalls}}
{{ccomment|die dazugehörige Funktion funcx mit Argument arg aus.}}
{{ccomment|Liefert den Rückgabewert von funcx}}
{{ccomment|oder -1, falls text nicht gefunden wurde.}}
int execute (const char *text)
{
{{ccomment|Schleifenvariable}}
unsigned char i;

{{ccomment|Wandert durch das Array mit Kommando-Strukturen}}
const command_t * cmd = commands;

{{ccomment|sizeof wird von gcc ausgewertet und ist wie eine Konstante,}}
{{ccomment|denn beide sizeofs sind zur Compilezeit bekannt}}
for (i=0; i < sizeof(commands) / sizeof (command_t); i++)
{
const prog_char * text_P;

{{ccomment|Liest die Startadresse von str_x}}
text_P = (const prog_char *) pgm_read_word (& cmd->text);

{{ccomment|Ist das der gesuchte String?}}
if (strcmp_P (text, text_P))
{
...

==Lokale Variablen verwenden==

Beim Manipulieren globaler Variablen kann es günstig sein, diese in eine lokale Variable zu kopieren, dort zu verändern, und sie danach wieder zu schreiben
<pre>
char var;

void foo1()
{
var++;
if (var > 10)
var = 1;
}
</pre>
Dadurch wird einmal unnötig gespeichert (der dritte Befehl kann vermieden werden).
<pre>
foo1:
lds r24,var ; *movqi/4 [length = 2]
subi r24,lo8(-(1)) ; addqi3/2 [length = 1]
sts var,r24 ; *movqi/3 [length = 2]
cpi r24,lo8(11) ; cmpqi/2 [length = 1]
brlt .L3 ; branch [length = 1]
ldi r24,lo8(1) ; *movqi/2 [length = 1]
sts var,r24 ; *movqi/3 [length = 2]
.L3:
ret
</pre>
Indem man eine lokale Variable (<tt>var2</tt>) verwendet für die Änderung von <tt>var</tt> vermeidet man dies:
<pre>
char var;

void foo2()
{
char var2 = var;

var2++;
if (var2 > 10)
var2 = 1;

var = var2;
}
</pre>
Dadurch wird erst am Ende gespeichert. <tt>var2</tt> lebt in Register <tt>r24</tt>.
<pre>
foo2:
lds r24, var ; *movqi/4 [length = 2]
subi r24,lo8(-(1)) ; addqi3/2 [length = 1]
cpi r24,lo8(11) ; cmpqi/2 [length = 1]
brlt .L2 ; branch [length = 1]
ldi r24,lo8(1) ; *movqi/2 [length = 1]
.L2:
sts var, r24 ; *movqi/3 [length = 2]
ret
</pre>

Bei diesem einfachen Beispiel spart man lediglich eine Instruktion. Bei komplexeren Rechnungen oder längeren Datentypen kann es aber durchaus lohnender sein, in lokale Register zu kopieren.

==Arithmetik==

=== Daten zerlegen/zusammensetzen ===

In systemnahen Programmen hat man oft was Problem, auf die einzelnen Bytes oder Bitfelder einer grösseren Datenstruktur zuzugreifen. Indem man sich ein Komposit baut, das die gewünschten Strukturen überlagert, kann man effizient z.B. auf Bytes zugreifen. Ausnahme sind Bitfelder, deren Verwendung etwas breiten Code ergibt. Bitfelder "von Hand" zu manipulieren, ist da manchmal effizienter, führt jedoch zu schlecht lesbarem Code.

Oft benötigt wird der Zugriff auf die einzelnen Bytes eines <tt>int</tt>, also der Zugriff auf die Bytes eines 16-Bit-Wertes:

typedef union
{
unsigned char asByte[2];
unsigned short asWord;
int asInt;
} data16_t;

data16_t data;
...
int foo;
uint8_t wert;

data.asInt = foo;
wert = data.asByte[1]; {{ccomment|die oberen 8 Bits von foo}}

Ein komplexeres Beispiel, das noch mehr Datentypen überlagert:
typedef ... foo_t;

typedef union
{
unsigned char byte[4]; {{ccomment| Zugriff als Bytes (8 Bit) }}
unsigned short word[2]; {{ccomment| Zugriff als Words (16 Bit) }}
signed long slong; {{ccomment| Zugriff als signed long (32 Bit) }}

struct {{ccomment| Zugriff auf einzelne Bitgruppen }}
{
unsigned bit_0_3 : 4; {{ccomment| 4 Bits (0..3) }}
unsigned bit_4_8 : 5; {{ccomment| 5 Bits (4..8) }}
unsigned bit_9_21 : 13; {{ccomment| 13 Bits (9..21) }}
unsigned bit_22_31: 10; {{ccomment| 10 Bits (22..31) }}
};

foo_t foo; {{ccomment| Zugriff als foo-Struktur }}
} data_t;

...
{
data_t data;

data.byte[2] = 12; {{ccomment| setzt byte 2 auf 12 }}
data.bit_4_8 = 0x1f; {{ccomment| setzt bits 4..8 (5 Stück) alle auf 1 }}

int anInt = data.foo.anInt; {{ccomment| liest ein Feld von foo (hier ein int) }}
...
}

===libgcc2 verwenden===

In der libgcc2 sind einige Arithmetik-Routinen in Assembler implementiert. Dazu gehören ein paar Algorithmen zu Division (mit Rest) und Multiplikation.

Von diesen Algorithmen werden durch die avr-libc jedoch nur zwei Strukturen und Funktionen veröffentlicht: <tt>div_t</tt> und <tt>ldiv_t</tt> resp. die Funktionen <tt>div()</tt> und <tt>ldiv()</tt>. Siehe dazu deine Dokumentation zur avr-libc. Damit kann man Quotient und zusätzlich den Rest bei einer Division 16/16 bzw. 32/32 berechnen lassen; den Rest bekommt man quasi kostenlos als Nebenprodukt. Das ist praktisch, wenn man z.b. eine Zahl in Dezimaldarstellung umwandeln möchte oder von/nach [[BCD]].

Zusätzlich zu den via avr-libc veröffentlichten Funktionen gibt es aber noch Routinen, die z.B. auf 8-Bit-Werten operieren oder mit <tt>unsigned</tt> Typen und dementsprechend effizienter sind.

'''Beispiel: Umwandeln nach Dezimalstring'''

Hier ein Beispiel, das Division mit Rest für <tt>unsigned short</tt> verwendet, um eine 16-Bit-Zahl in Dezimaldarstellung zu wandeln:

{{ccomment| Struktur definieren und Funktion bekannt machen }}
typedef struct
{
unsigned short quot;
unsigned short rem;
} udiv_t;

extern udiv_t udiv (unsigned short, unsigned short) __asm__("__udivmodhi4");

{{ccomment| 5 Ziffern (0...65535) und evtl. noch eine führende 0 }}
#define DIGITS 6

{{ccomment| +1 wegen String-Ende (wird im Startup auf 0 gesetzt) }}
char string[DIGITS+1];

{{ccomment| Wandelt zahl in Dezimaldarstellung um. }}
{{ccomment| Der return-Wert zeigt irgendwo ins string[]-Array. }}
{{ccomment| string[] wird verändert. }}
char* toString (unsigned short zahl)
{
{{ccomment| s zeigt auf das Ende von string }}
{{ccomment| string wird von hinten nach vorne gefüllt }}
char *s = string + DIGITS;

{{ccomment| qrem enthält Quotient (quot) und Rest (rem) der Divisionen }}
udiv_t qrem = {.quot = zahl};

do
{
{{ccomment| Division mit Rest durch 10 }}
{{ccomment| quot: Ergebnis für den nächsten Durchlauf }}
{{ccomment| rem: Rest ist die Ziffer im 10er-System }}
qrem = udiv (qrem.quot, 10);

{{ccomment| Ziffer in Zeichen wandeln und speichern }}
*(--s) = '0' + qrem.rem;
}
while (0 != qrem.quot);

{{ccomment| Falls eine führende '0' gespeichert wurde: weg damit }}
{{ccomment| ausser zahl war selbst schon 0 }}
if (*s == '0' && *(s+1) != '\0')
s++;

return s;
}

Falls man eine Division und/oder Rest für 8-Bit braucht, dann geht für <tt>unsigned</tt> analog.

'''Beispiel: BCD-Umrechnung'''

Wandeln einer 8-Bit-Zahl <tt>0 <= num < 100</tt> nach [[BCD]]

typedef struct
{
unsigned char quot; {{ccomment| Quotient }}
unsigned char rem; {{ccomment| Rest (remainder) }}
} udiv8_t;

extern udiv8_t udiv8 (unsigned char, unsigned char) __asm__ ("__udivmodqi4");

{{ccomment| Wandelt num nach BCD um, 0 <= num <= 99 }}
{{ccomment| return-Wert ist dann 0x0 <= return <= 0x99 }}
unsigned char to_bcd (unsigned char num)
{
udiv8_t qrem = udiv8 (num, 10);

return (unsigned char) (qrem.quot << 4) | qrem.rem;
}

===Division durch Multiplikation===
===Vermeiden von float und double===

=Inkompatibilität=

[[GCC]] – und somit auch avr-gcc – werden ständig weiter entwickelt. Dies betrifft das Beheben von Fehlern, die Unterstützung neuer Architekturen/Sprachen/Betriebssysteme, Implementierung neuer Optimierungsalgorithmen, Vereinheitlichungen, etc.

Leider führt dies auch zu Inkompatibilitäten verschiedener avr-gcc-Versionen untereinander, und eine C-Quelle, die mit einer Version von avr-gcc fehler- und warnungsfrei übersetzt werden kann, ist mit einer anderen Version möglicherweise nicht compilierbar.

Die avr-gcc Version kann man anzeigen lassen, indem man in einer Shell/Eingabeaufforderung eintippt
avr-gcc -v

;<tt>#include <avr/signal.h></tt>: In Versionen bis 3.4.4 werden in dieser Header-Datei u.a. die Makros <tt>SIGNAL()</tt> und <tt>INTERRUPT()</tt> definiert, die man braucht, wenn man eine C-Funktion als Interrupt-Routine ([[ISR]]) kennzeichnen will. In neueren Versionen ab 3.4.5 sind diese Definitionen in den Header <tt>avr/interrupt.h</tt> gewandert, wo auch Makros wie <tt>sei()</tt> und <tt>cli()</tt> definiert werden. Die Inkludierung von <tt>avr/signal.h</tt> in den neueren avg-gcc Versionen führt zu einer Warnung, irgendwann vielleicht sogar zu einem Fehler, weil die Datei nicht mehr bei avr-gcc dabei ist und daher nicht mehr gefunden wird.
: '''Verwendet man bei einer älteren avr-gcc-Version <tt>SIGNAL</tt> bzw. <tt>INTERRUPT</tt> ohne <tt>avr/signal.h</tt> zu includen, wird u.U. stillschweigend falscher Code erzeugt.'''

;<tt>#include <util/...h></tt>: In <tt>util</tt> stehen jetzt Header wie <tt>util/parity.h</tt> oder das vielverwendete <tt>util/delay.h</tt>, die vormals im Include-Unterverzeichnis <tt>avr</tt> zu finden waren.

;Interrupt Service Routinen: Auch die API zur Definition von [[ISR]]s hat sich von avr-gcc Version 3.x zur Version 4.x geändert:
:'''avr-gcc 3.x'''
::{|
<pre>
SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

INTERRUPT (SIG_OVERFLOW0)
{
/* Interrupt Code */
}
</pre>
|}

:'''avr-gcc 4.x'''
::{|
<pre>
ISR (INT0_vect)
{
/* Interrupt Code */
}

void TIMER0_OVF_vect (void) __attribute__((interrupt));
void TIMER0_OVF_vect (void)
{
/* Interrupt Code */
}
</pre>
|}

=Bugs=

==== Bit 7 bei SFR-Zugriff ====

Bei Sequenzen wie
PORTB &= ~ (1 << 7);
PORTD &= ~ (1 << 7);

macht avr-gcc eine CSE-Optimierung (common subexpression elimination). Er legt die Konstante 127 (<tt>~(1 << 7)</tt>) in ein Register und verwendet den Registerinhalt, anstatt die Konstante direkt zu verwenden.

Das führt dazu, daß statt der gewünschten Befehlsfolge
; Sequenz 1
cbi 37-0x20, 7
cbi 43-0x20, 7
Sequenzen folgender Gestalt erzeugt werden:
; Sequenz 2
ldi r18, lo8(127) ; 127 nach R18

in r19, 37-0x20 ; PORTB nach R19 lesen
; Wird hier eine ISR ausgeführt, die PORTB verändert, dann wird die
; Änderung mit dem folgenden OUT überschrieben
and r19, r18 ; oberstes Bit löschen
; dito
out 37-0x20, r19 ; PORTB schreiben

in r19, 43-0x20 ; analog
and r19, r18
out 43-0x20, r19

Abgesehen davon, daß Sequenz 2 deutlich mehr Programmspeicher und Laufzeit benötigt als Sequenz 1, kann es zu folgendem Fehler kommen:

Bei der zweiten Codesequenz erfolgt der Zugriff auf die SFRs nicht atomar. Wird der C-Code in einem Programm ausgeführt, das in einer [[ISR]] zB Port B3 verändert und wird diese ISR zwischen dem IN und dem OUT Befehl ausgeführt, dann überschreibt der OUT-Befehl den Wert von PORTB und die Aktion für Port B3 in der ISR wird wieder rückgängig gemacht. Das ist dann ein Programmfehler.

Damit das Problem zum Tragen kommt, müssen mehrere Bedingungen erfüllt sein:
* Bei mindestens zwei C-Befehlen wird der Wert 127 als 8-Bit-Wert benötigt. Das ist zB auch der Fall, wenn dieser Wert nur gespeichert wird oder modulo 0x80 gerechnet wird.
* Mindestens einer dieser Befehle löscht Bit 7 eines SFR aus dem bitadressierbaren I/O-Bereich. (Ausser PORTx oder DDRx sind in diesem Bereich noch weitere SFR untergebracht.)
* Im Programm wird auf unterschiedlichen [[Interrupt]]-Ebenen auf dieses SFR zugegriffen und die oben gezeigt Stelle kann von der ISR unterbrochen werden.
* Die beiden C-Befehle müssen nicht unmittelbar aufeinander folgen. Es können auch andere C-Befehle dazwischen stehen.

Bei den meisten Programmen wird das angesprochene Problem nicht zu einem Fehler führen. Falls doch, kann man dem begegnen mit folgenden

;Workarounds:
* Die C-Stelle wird in CLI/SEI eingeschlossen und kann damit nicht mehr von einer ISR unterbrochen werden.
* Alternativ schreibt man vor und nach jedem problematischen SFR-Zugriff folgendes Kommando:
:{|
|-
|
__asm volatile (""::);
|}
:Dieses Kommando erzeugt keine Assembler-Instruktionen, vermeidet aber die unerwünschte "Optimierung" im gcc, und es entsteht Code gemäß Sequenz 1.
* Alternativ definiert man sich ein Makro, mit dem man die Portzugriffe tätigt:
:{|
|-
|
#define CBI(A,B) __asm volatile ("cbi\t%0, %1" :: "M" (_SFR_IO_ADDR(A)), "M" (B))
|}
:Und löscht das Bit mit
:{|
|-
|
CBI (PORTB, 7);
|}

==== <tt>__builtin_return_address(0)</tt> ====
ist entgegen der Spezifikation nicht implementiert und liefert in der Regel ein falsches Ergebnis.

;Workaround:

(hier für eine ISR):
#include <stdarg.h>
#include <avr/interrupt.h>

{{ccomment|The return address}}
unsigned short volatile return_addr;

{{ccomment|Define our special SIGNAL (INTERRUPT analoguous)}}
#define SIGNAL_BRA(signame,var) \
void signame (unsigned short var, ...) __attribute__ ((signal)); \
void signame (unsigned short var, ...)

#define SWAP_BYTES(x) (((x) >> 8) | ((x) << 8))

SIGNAL_BRA (SIG_OUTPUT_COMPARE1A, dummy)
{
{
va_list vlist;
va_start (vlist, dummy);

{{ccomment|Get the return address from the stack}}
dummy = va_arg (vlist, unsigned short);

{{ccomment|Convert stack address to code location}}
addr = SWAP_BYTES(dummy) << 1;
va_end (vlist);
}
{{ccomment|ISR Code}}
}

==== gcc 4.x ====

In der 4er-Version gab es tiefgreifende interne Änderungen im Compiler; er ist noch instabil und kann momentan nicht für den Produktiv-Einsatz empfohlen werden (Stand 02/2006).

Die Auswirkungen der Optimierungen auf das Zielsystem <tt>avr</tt> bleibt abzuwarten, dürfte aber nicht wesentlich sein. Die neue 4-er Version wurde u.a. deshalb aufgelegt, um mit dem Intel-Compiler gleichzuziehen – also im Hinblick auf das Zielsystem <tt>i386</tt>) gemacht.

Auch nach dem Release der 4-er Version wird die 3-er Version weiterentwickelt, da erst nach 1-2 Jahren nach Release einer neuer Major-Version ein Umstieg anzuraten ist und auch erst dann getätigt wird (zumindest im professionellen Bereich).

=Abkürzungen und Bezeichnungen=
; [[GCC]]: GNU Compiler Collection
; gcc: GNU C-Compiler
; GPR: '''G'''eneral '''P'''urpose '''R'''egister
; [[ISR]]: [[Interrupt|'''I'''nterrupt]] '''S'''ervice '''R'''outine
; [[IRQ]]: '''I'''nterrupt '''R'''e'''q'''uest
; Prolog/Epilog: Code am Anfang/Ende jeder Funktionen/ISR, der dazu dient, verwendete Register zu sichern, den Stack-Frame für lokale [[Variable|Variablen]] anzulegen (falls benötigt), Stackpointer zu setzen, zurück zu springen (<tt>ret</tt>, <tt>reti</tt>), etc.
; SFR: '''S'''pecial '''F'''unction '''R'''egister
; Target: Zielsystem, in unserem Falle avr

=Siehe auch=
* [[C-Tutorial]]
'''Code-Beispiele'''
* [[Hallo Welt für AVR (LED blinken)]] - ein erstes Beispiel für avr-gcc
*[[:Kategorie:Quellcode_C|C-Codebeispiele]]
* [[Fallstricke bei der C-Programmierung]]

'''Details'''
* [[Inline-Assembler in avr-gcc|Inline-Assembler]]
* [[avr-gcc/Interna|Interna von avr-gcc]]

'''Installation (Linux)'''
* [[Linuxdistribution_Avr-live-cd]]
* [[avr-gcc und avrdude installieren]]
'''Sonstiges'''
* [[WinAVR]]
* [[Speicherverbrauch bestimmen mit avr-gcc]]
* [[Compiler]]
* [[Dev-Cpp IDE]]
* [[AVR]]
----
* [[Sourcevergleich]]
* [[Codevergleich AVR-Compiler]]

=Weblinks=
==Dokumentation==
* [http://gcc.gnu.org/onlinedocs/ GCC online documentation (en)] Offline findest du die Doku für gcc, cpp (Präprozessor) und avr-libc bei [[WinAVR]] in
:<pre><GCC_HOME>/doc/gcc/</pre>
: bzw.
:<pre><GCC_HOME>/doc/avr-libc/</pre>
:Online finden sich die Dokumente in
* [http://gcc.gnu.org/onlinedocs/gcc.pdf gcc.pdf (1900 kByte)] - Dokumentation des C/C++/Java-Compilers GCC (en)
* [http://gcc.gnu.org/onlinedocs/cpp.pdf cpp.pdf (470 kByte)] - Dokumentation des C-Präprozessors (en)
* [http://www.nongnu.org/avr-libc/user-manual/modules.html http://www.nongnu.org/avr-libc/user-manual] - Dokumentation zur avr-libc.

== Downloads==
* [http://sourceforge.net/projects/winavr/ WinAVR-Projekt bei sourceforge.net (en)]
* [http://cdk4avr.sourceforge.net/ avr-gcc und toolchain als Linux-Paket bei sourceforge.net (en)]
* [[Linuxdistribution_Avr-live-cd]]
== Tipps, Installation ==
*[http://www.nongnu.org/avr-libc/user-manual/install_tools.html ''"Installing the GNU Tool Chain"''] Hilfe zum Build und Installation von GCC, binutils, etc unter Linux
* Im GCC-Handbuch, siehe [[#Dokumentation|Dokumentation]].
* [http://www.linuxfocus.org/Deutsch/November2004/article352.shtml www.linuxfocus.org (Artikel)] - Tipps zu Build und Installation von avr-gcc, binutils und avr-libc unter Linux
* [http://users.rcn.com/rneswold/avr/ Rich Neswold: ''A GNU Development Environment for the AVR Microcontroller'']
* [http://www.mikrocontroller.net/topic/24166 www.mikrocontroller.net (Foren-Beitrag)] - Installation von GCC und Toolchain unter Mac OS X
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=125603#125603 www.roboternetz.de (Foren-Beitrag)] ''avrgcc + avrdude installieren''

== Sonstiges ==
* [http://gcc.gnu.org/ Offizielle Homepage von GCC (en)]
* [http://de.wikipedia.org/wiki/GNU_Compiler_Collection GCC in der deutschen Wikipedia]
* [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial avr-gcc-Tutorial auf mikrocontroller.net]
* [http://www.avrfreaks.net/AVRGCC/ avr-gcc bei avrfreaks.net (en)]
* [http://savannah.nongnu.org/projects/avr-libc/ Nützliche GCC Runtime-Libary]

=Autor=

--[[Benutzer:SprinterSB|SprinterSB]] 11:27, 7. Dez 2005 (CET)

[[Kategorie:Grundlagen]]
[[Kategorie:Microcontroller]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]

Avr-gcc

2007-03-20T10:09:32Z

Inrfb2: /* Interrupts */

'''avr-gcc''' ist ein freier C-[[Compiler]], mit dem man C-Programme zu ausführbaren Programmen übersetzen kann, die auf [[Microcontroller]]n der [[AVR]]-Familie lauffähig sind.
An Sprachen versteht avr-gcc sowohl C als auch [[#C%2b%2b|C++]].
Neben Standard-C bzw. ANSI-C versteht avr-gcc auch GNU-C, das etwas mehr Möglichkeiten und kleinere Spracherweiterungen bietet.

avr-gcc kann auch dazu verwendet werden, um C/C++ Programme nach Assembler zu übersetzen oder um Bibliotheken zu erstellen, die später in unterschiedlichen Projekten verwendet werden können.

Wie bei allen aus der UNIX-Welt kommenden Programmen ist das Kommando-Interface von avr-gcc die Shell bzw. die Kommandozeile, über die Optionen, Parameter, Einstellungen und die Namen der zu übersetzenden Dateien angegeben werden.

=How to Read=

Dieser Artikel bespricht avr-gcc Version 3.x. Er ist kein C-Tutorial und kein AVR-Handbuch – das würde den Umfang des Artikels bei weitem sprengen.

Der Artikel ist ein Handbuch zu avr-gcc. Er bespricht zum Beispiel, wie man avr-gcc anwendet und Besonderheiten von avr-gcc-C,
die nicht zum Sprachumfang von C gehören.
Dazu zählen die Definition von [[#Interrupts|Interrupt]] Service Routinen ([[ISR|ISRs]])
oder wie man Daten ins [[EEPROM]] legt.

Es wird also besprochen, ''wie'' eine ISR zu definieren ist, aber nicht,
''warum'' das gegebenenfalls notwendig oder nicht notwendig ist.
''Warum'' etwas gemacht wird, ist abhängig von der gestellten Aufgabe,
etwa ''"Initialisiere den [[UART]] zur Benutzung mit 9600 Baud"''.
Dafür enthält dieser Artikel zusammen mit dem AVR-Handbuch das Rüstzeug,
bietet aber keine Lösungen für konkrete Aufgaben.

Neben diesem Artikel gibt es den Unterartikel [[avr-gcc/Interna|Interna von avr-gcc]] wo Dinge wie die Registerverwendung, Attribute, Builtins und Sections von avr-gcc dargestellt werden. Zudem findet sich dort ein Überblick über die Arbeitsweise von gcc mit den Schritten
* Precompilieren
* Compilieren
* Assemblieren
* Linken
Ein weiterer Unterartikel widmet sich dem Thema [[Inline-Assembler in avr-gcc]].

In den [[:Kategorie:Quellcode C|C-Codebeispielen]]
befindet sich das ausführlichere Beispiel "[[Hallo Welt für AVR (LED blinken)]]",
das nur eine [[Diode#Lumineszenzdiode|LED]] blinkt und zeigt,
wie ein kleines Projekt mit avr-gcc compiliert werden kann.

Es gibt ein [[C-Tutorial]], das jedoch noch unvollständig und teilweise feherhaft ist (Stand 02/2006). Darüber hinaus gibt es ein [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial C-Tutorial bei www.mikrocontroller.net].

=Benutzer-Schnittstelle=

Die Benutzer-Schnittstelle von avr-gcc ist – wie für alle Programme, die aus der UNIX-Welt kommen – die Kommandozeile einer Shell, Console bzw. Eingabeaufforderung.

Im einfachsten Fall sieht ein Aufruf von avr-gcc also so aus:
> avr-gcc
Dabei das '<tt>></tt>' nicht mittippen, und ein ENTER am Ende der Zeile drücken.
Die Antwort bei korrekter Installation ist dann
avr-gcc: no input files
Was bedeutet: das Programm avr-gcc wurde vom Betriebssystem gefunden und konnte/durfte gestartet werden. Dann gibt avr-gcc eine Fehlermeldung aus und beendet die Ausführung, weil er keine Eingabedatei(en) bekommen hat was ja auch stimmt. Soweit ist also alles in Butter.

Um eine C-Datei <tt>foo.c</tt> mir avr-gcc optimiert zu einem lauffähigen elf-Programm <tt>foo.elf</tt> für einen [[ATmega32]] zu compileren, würde man angeben
> avr-gcc -O2 -mmcu=atmega32 foo.c -o foo.elf
Hat man seine Quellen auf zwei oder mehre Dateien verteilt, geht es analog:
> avr-gcc -O2 -mmcu=atmega32 foo.c foo2.c -o foo.elf

Will man nur eine Objekt-Datei erstellen (nur compilieren, nicht linken), dann geht das wie folgt. Das kann günstig sein bei grösseren Projekten, wenn man das Projekt neu erzeugen will, aber nur in einer Quelldatei was geändert hat. Oder wenn das Objekt in einer Bibliothek landen soll.
> avr-gcc -O2 -c -mmcu=atmega32 foo.c -o foo.o

Die ausführbare Gesamtdatei <tt>foo_all.elf</tt> erhält man dann, indem alle Objekte zusammenlinkt:
> avr-gcc -mmcu=atmega32 foo.o foo2.o foo3.o -o foo_all.elf

Um die ausführbare Datei in das oft verwendete Intex-HEX-Format umzuwandeln (einmal fürs Programm, einmal für ein Abbild des [[EEPROM]]s) gibt man an:
> avr-objcopy -O ihex -j .text -j .data foo_all.elf foo_all.hex
> avr-objcopy -O ihex -j .eeprom --change-section-lma .eeprom=0 foo_all.elf foo_all_eeprom.hex

----

[[GCC]] war immer Kommandozeilen-orientiert und wird es auch immer bleiben, denn das hat gute Gründe:
* ein Compiler ist ein Compiler ist ein Compiler (und keine grafische Bedienschnittstelle)
* die Plattformabhängigkeit wird auf ein Minimum reduziert
* es gibt die Möglichkeit, avr-gcc per Skript oder [[make]] zu starten
* avr-gcc kann durchaus in eine Umgebung integriert werden: in einen Editor oder in eine GUI wie neuere Versionen von AVR-Studio erfolgreich beweisen, etc. Der avr-gcc-Aufruf kann sogar von einem Server-Socket oder einer Web-Application heraus erfolgen, welche ein C-Programm empfängt, es von avr-gcc übersetzen lässt, und das Resultat zurückschickt oder sonst was damit anstellt.
* Lizenzgründe: eine Umgebung, die avr-gcc integriert, kann durchaus proprietär oder nicht quelloffen sein und muss nicht der [[Freie Software|GPL]] unterliegen. Wieder ist AVR-Studio ein Beispiel.

= Unterstützte AVR-Derivate=
;Classic AVR:: [[AT90S1200]], [[AT90S2313]], [[AT90S8515]], [[AT90S8535]], [[AT90S4433]], [[AT90S4414]], [[AT90S4434]], [[AT90S2323]], [[AT90S2333]], [[AT90S2343]],

;tinyAVR:: [[ATtiny10]], [[ATtiny11]], [[ATtiny12]], [[ATtiny15]], [[ATtiny28]], [[ATtiny22]], [[ATtiny26]], [[AT90C8534]], [[AT86rf401]], [[ATtiny13]], [[ATtiny2313]], [[ATtiny261]], [[ATtiny461]], [[ATtiny861]], [[ATtiny24]], [[ATtiny44]], [[ATtiny84]], [[ATtiny25]], [[ATtiny45]], [[ATtiny85]]

;megaAVR:: [[ATmega603]], [[ATmega103]], [[AT76C711]], [[ATmega48]], [[ATmega8]], [[ATmega83]], [[ATmega85]], [[ATmega88]], [[ATmega8515]], [[ATmega8535]], [[ATmega16]], [[ATmega161]], [[ATmega162]], [[ATmega163]], [[ATmega164p]], [[ATmega165]], [[ATmega165P]], [[ATmega168]], [[ATmega32]], [[ATmega323]], [[ATmega324P]], [[ATmega325]], [[ATmega3250]], [[ATmega64]], [[ATmega640]], [[ATmega644]], [[ATmega644P]], [[ATmega128]], [[ATmega1280]], [[ATmega1281]], [[ATmega645]], [[ATmega6450]], [[AT94K]]

; [[LCD]] AVR:: [[ATmega169]], [[ATmega169P]], [[ATmega329]], [[ATmega3290]], [[ATmega649]], [[ATmega6490]],
; Lightning AVR:: [[AT90PWM2]], [[AT90PWM3]]
; [[CAN]] AVR:: [[AT90CAN32]], [[AT90CAN64]], [[AT90CAN128]]
; Smart Battery:: [[ATmega406]]
; [[USB]] AVR:: [[AT43USB320]], [[AT43USB355]], [[AT90USB646]], [[AT90USB647]], [[AT90USB1286]], [[AT90USB1287]]
;

Diese Liste kann man avr-gcc anzeigen lassen mit
> avr-gcc --target-help

=Kommandozeilen-Optionen=
Die Codegenerierung bei avr-gcc wird über Kommandozeilen-Optionen gesteuert. Diese legen fest, für welchen Controller Code zu erzeugen ist, wie stark optimiert wird, ob Debug-Informationen erzeugt werden, etc. Die Optionen teilen sich in zwei Gruppen: Optionen, die für alle GCC-Ports verfürgbar sind und maschinenspezifische Optionen, die nur für AVR verfügbar sind.

Aus der Masse an GCC-Optionen kann hier nur ein kleiner Auszug der wichtigsten und am häufigsten verwendeten Optionen vorgestellt werden. Eine Auflistung aller GCC-Optionen mit Kurzbeschreibung umfasst knapp 1000 Zeilen ohne undokumentierte Optionen, versteht sich.

==Allgemeine Optionen für GCC==
; <tt>--help</tt>: Anzeige der wichtigsten Optionen
; <tt>--help -v</tt>: Überschüttet einen mit Optionen
; <tt>--target-help</tt>: Anzeige der wichtigsten maschinenspezifischen Optionen und der unterstützten AVR-Derivate
; <tt>-O0</tt>: keine Optimierung
; <tt>-O1</tt>: Optimierung
; <tt>-Os</tt>: optimiert für Code-Größe
; <tt>-O2</tt>: stärkere Optimierung für bessere Laufzeit
; <tt>-g</tt>: erzeugt Debug-Informationen
; <tt>-c</tt>: (pre)compilert und assembliert nur bis zum Objekt (<tt>*.o</tt>), kein Link-Lauf
; <tt>-S</tt>: (pre)compilert nur und erzeugt Assembler-Ausgabe (*.s)
; <tt>-E</tt>: nur Precompilat (<tt>*.i</tt>) erzeugen, kein Compilieren, kein Assemblieren, kein Linken
; <tt>-o <filename></tt>: legt den Name der Ausgabedatei fest
; <tt>-v</tt>: zeigt Versionsinformationen an und ist geschwätzig (verbose): Anzeige der aufgerufenen tools
; <tt>-I<path></tt>: Angabe eines weiteren Include-Pfads, in dem Dateien mit <tt>#include <...></tt> gesucht werden
; <tt>-E -dM <filename></tt>: Anzeige aller Defines
; <tt>-MM</tt>: Für die angegebenen Eingabe-Dateien wird eine Ausgabe erzeugt, die als [[make|Makefile]]-Fragment dienen kann und die Anhängigkeiten (dependencies) der Objekte von den Quellen/Headern beschreibt.
; <tt>-D<name></tt>: Definiert Makro <tt><name></tt>
; <tt>-D<name>=<wert></tt>: Definiert Makro <tt><name></tt> zu <tt><wert></tt>
; <tt>-U<name></tt>: Undefiniert Makro <tt><name></tt>
; <tt>-save-temps</tt>: Temporäre Dateien (<tt>*.i</tt>, <tt>*.s</tt>) werden nicht gelöscht. Teilweise fehlerhaft zusammen mit <tt>-c</tt>
; <tt>-Wa,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Assembler (<tt>avr-as</tt>)
:;<tt>-Wa,-a=<filename></tt>: Assembler erzeugt ein Listing mit Name <tt><filename></tt>
; <tt>-Wp,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Preprozessor
; <tt>-Wl,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Linker (<tt>avr-ld</tt>)
:;<tt>-Wl,-Map=<filename></tt>: Linker erzeugt ein Map-File mit Name <tt><filename></tt>
:;<tt>-Wl,--oformat=<format></tt>: Linker erzeugt Ausgabe im Format <tt><format></tt>, z.b. <tt>ihex</tt> für Intel-HEX-File
:;<tt>-Wl,--section-start=<section>=<address></tt>: Linker legt die [[avr-gcc/Interna#Sections|Section]] <tt><section></tt> ab Adresse <tt><address></tt>, z.B: <tt>.eeprom=0x810001</tt>
; <tt>-Wall</tt>: gibt mehr Warnungen, aber immer noch nicht alle
; <tt>-pedantic</tt>: geht besonders pedantisch mit Code um
; <tt>-std=c89 -ansi</tt>: bricht mit einer Fehlermeldung ab, wenn kein ANSI-C (ISO C89) verwendet wurde
; <tt>-std=c99</tt>: bricht mit einer Fehlermeldung ab, wenn kein ISO C99 verwendet wurde
; <tt>-ffreestanding</tt>: Das erzeugte Programm läuft nicht in einer Umgebung wie einer Shell. Der Prototyp von <tt>main</tt> ist
:<pre>void main (void);</pre>

==Maschinenspezifische Optionen für avr-gcc==
Maschinenabhängige Optionen beginnen immer mit '''-m'''
;-mmcu=xxx: Festlegen des Targets (Zielsystem/Controller), für das Code generiert werden soll. Je nach Target muss avr-gcc unterschiedliche Instruktionen verwenden und andere Startup-Dateien (<tt>crtxxx.o</tt>) einbinden. avr-gcc setzt spezielle Defines, um auch in der Quelle zwischen den Targets unterscheiden zu können, falls das notwendig sein sollte:
:{| border="0" cellpadding="0" cellspacing="0"
|
<pre>
#ifdef __AVR_AT90S2313__
/* Code fuer AT90S2313 */
#elif defined (__AVR_ATmega8__) || defined (__AVR_ATmega32__)
/* Code fuer Mega8 und Mega32 */
#else
#error Das ist noch nicht implementiert für diesen Controller!
#endif
</pre>
|}

Zwar gibt es für alle AVR-Derivate die <tt>avr/io.h</tt>, aber die AVR-Familien unterscheiden sich in ihrer Hardware; z.B. darin, wie I/O-Register heissen oder wie Hardware zu initialisieren ist. Diese Abhängigkeit kann man in unterschiedlichen Codestücken aufteilen und wie oben gezeigt bedingt übersetzen. Dadurch hat man Funktionalitäten wie <tt>uart_init</tt> auf unterschiedlichen Controllern und wahrt den Überblick, weil nicht für jede Controller-Familie eine extra Datei notwendig ist.
{|
|- valign="top"
|
:{| {{Blauetabelle}}
|+ '''AVR classic, <= 8 kByte'''
|- {{Hintergrund1}}
!|mcu || Builtin define
|-
|avr2 ||<tt>__AVR_ARCH__=2</tt>
|-
|[[AT90S2313|at90s2313]] ||<tt>__AVR_AT90S2313__</tt>
|-
|at90s2323 ||<tt>__AVR_AT90S2323__</tt>
|-
|at90s2333 ||<tt>__AVR_AT90S2333__</tt>
|-
|at90s2343 ||<tt>__AVR_AT90S2343__</tt>
|-
|attiny22 ||<tt>__AVR_ATtiny22__</tt>
|-
|attiny26 ||<tt>__AVR_ATtiny26__</tt>
|-
|at90s4414 ||<tt>__AVR_AT90S4414__</tt>
|-
|at90s4433 ||<tt>__AVR_AT90S4433__</tt>
|-
|at90s4434 ||<tt>__AVR_AT90S4434__</tt>
|-
|at90s8515 ||<tt>__AVR_AT90S8515__</tt>
|-
|at90c8534 ||<tt>__AVR_AT90C8534__</tt>
|-
|at90s8535 ||<tt>__AVR_AT90S8535__</tt>
|-
|at86rf401 ||<tt>__AVR_AT86RF401__</tt>
|}
| 
:{| {{Blauetabelle}}
|+ '''AVR classic, > 8 kByte'''
|- bgcolor="#ccccff"
! |mcu ||Builtin define
|-
|avr3 ||<tt>__AVR_ARCH__=3</tt>
|-
|atmega103 ||<tt>__AVR_ATmega103__</tt>
|-
|atmega603 ||<tt>__AVR_ATmega603__</tt>
|-
|at43usb320 ||<tt>__AVR_AT43USB320__</tt>
|-
|at43usb355 ||<tt>__AVR_AT43USB355__</tt>
|-
|at76c711 ||<tt>__AVR_AT76C711__</tt>
|}
|}

----

{|
|- valign="top"
|
:{| {{Blauetabelle}}
|+ '''AVR enhanced, <= 8 kByte'''
|- bgcolor="#ccccff"
!|mcu || Builtin define
|-
|avr4 ||<tt>__AVR_ARCH__=4</tt>
|-
|[[Atmel Controller Mega8|atmega8]] ||<tt>__AVR_ATmega8__</tt>
|-
|atmega8515 ||<tt>__AVR_ATmega8515__</tt>
|-
|atmega8535 ||<tt>__AVR_ATmega8535__</tt>
|}
|
:{| {{Blauetabelle}}
|+ '''AVR enhanced, > 8 kByte'''
|- bgcolor="#ccccff"
!|mcu ||Builtin define
|-
|avr5 ||<tt>__AVR_ARCH__=5</tt>
|-
|[[Atmel Controller Mega16 und Mega32|atmega16]] ||<tt>__AVR_ATmega16__</tt>
|-
|atmega161 ||<tt>__AVR_ATmega161__</tt>
|-
|atmega162 ||<tt>__AVR_ATmega162__</tt>
|-
|atmega163 ||<tt>__AVR_ATmega163__</tt>
|-
|atmega169 ||<tt>__AVR_ATmega169__</tt>
|-
|[[Atmel Controller Mega16 und Mega32|atmega32]] ||<tt>__AVR_ATmega32__</tt>
|-
|atmega323 ||<tt>__AVR_ATmega323__</tt>
|-
|[[ATMega64|atmega64]] ||<tt>__AVR_ATmega64__</tt>
|-
|[[Atmel Controller Mega128|atmega128]] ||<tt>__AVR_ATmega128__</tt>
|-
|at94k ||<tt>__AVR_AT94K__</tt>
|}
|}

----

:{| {{Blauetabelle}}
|+ '''AVR, nur Assembler'''
|- bgcolor="#ccccff"
! |mcu ||Builtin define
|-
|avr1 ||<tt>__AVR_ARCH__=1</tt>
|-
|at90s1200 ||<tt>__AVR_AT90S1200__</tt>
|-
|attiny11 ||<tt>__AVR_ATtiny11__</tt>
|-
|attiny12 ||<tt>__AVR_ATtiny12__</tt>
|-
|attiny15 ||<tt>__AVR_ATtiny15__</tt>
|-
|attiny28 ||<tt>__AVR_ATtiny28__</tt>
|}

----

; -minit-stack=xxx: Festlegen der Stack-Adresse
; -mint8: Datentyp <tt>int</tt> ist nur 8 Bit breit, anstatt 16 Bit. Datentypen mit 32 Bit wie <tt>long</tt> sind nicht verfügbar
; -mno-interrupts: Ändert den Stackpointer ohne Interrupts zu deaktivieren
; -mcall-prologues: Funktions-Prolog und -Epilog werden als Unterroutinen umgesetzt, um die Codegröße zu verkleinern
; -mtiny-stack: Nur die unteren 8 Bit des Stackpointers werden verändert
; -mno-tablejump: Für ein <tt>switch</tt>-Statement werden keine Sprungtabellen angelegt
; -mshort-calls: Verwendet <tt>rjmp</tt>/<tt>rcall</tt> (begrenzte Sprungweite) auf Devices mit mehr als 8 kByte Flash
; -msize: Ausgabe der Instruktonslängen im asm-File
; -mdeb: (undokumentiert) Ausgabe von Debug-Informationen für GCC-Entwickler
; -morder1: (undokumentiert) andere Register-Allokierung
; -morder2: (undokumentiert) andere Register-Allokierung

=C++=

:''"C++ is a complex language and an evolving one, and its standard definition (the ISO C++ standard) was only recently completed. As a result, your C++ compiler may occasionally surprise you, even when its behavior is correct."''

Zudem sollte der Einsatz von C++ aus Effizienzgründen sehr kritisch betrachtet werden:
:''"When programming C++ in space- and runtime-sensitive environments like microcontrollers, extra care should be taken to avoid unwanted side effects of the C++ calling conventions like implied copy constructors that could be called upon function invocation etc. These things could easily add up into a considerable amount of time and program memory wasted. Thus, casual inspection of the generated assembler code (using the <tt>-S</tt> compiler option) seems to be warranted."''

Weiterhin unterliegt der Einsatz von C++ je nach Compiler/Lib-Version bestimmten Einschränkungen:
*Einer kompletten C++ Implementierung fehlt die Unterstützung durch die <tt>libstdc++</tt>, dadurch fehlen Standardfunktionen, -Klassen und -Templates
* Die Operatoren <tt>new</tt> und <tt>delete</tt> sind nicht implementiert, ihre Verwendung führt zu unauflösbaren externen Referenzen (Linker-Fehler)
*Nicht alle Header sind C++-sicher und müssen in <tt>extern "C" {...}</tt> eingeschlossen werden.
*Exceptions werden nicht unterstützt und müssen via <tt>-fno-exceptions</tt> abgeschaltet werden, oder der Linker beschwert sich über eine unauflösbare externe Referenz zu <tt>__gxx_personality_sj0</tt>.

Als Treiber verwendet man wie immer avr-gcc. Standard-Endungen für C++ sind <tt>.c++</tt> und <tt>.cpp</tt>. Bei anderen Endungen teilt man mit <tt>-x c++</tt> mit, daß es sich um C++ Dateien handelt, oder ruft <tt>avr-c++</tt> direkt auf.

Interrupt-Service-Routinen (ISRs) sind C-Funktionen und werden definiert wie gehabt. Siehe auch [[#Interrupts|Interrupts]].
#include <avr/io.h>
#include <avr/interrupt.h>

#if defined (__cplusplus)
extern "C" {
#endif {{comment|__cplusplus}}

SIGNAL (SIG_NAME)
{
{{comment|machwas}}
}

INTERRUPT (SIG_NAME)
{
{{comment|mach was}}
}

#if defined (__cplusplus)
}
#endif {{comment|__cplusplus}}
<tt>__cplusplus</tt> ist ein Standard [[avr-gcc/Interna#Builtin Defines|GCC-Builtin-Define]].

Globale Konstruktoren werden in [[avr-gcc/Interna#Sections|Section]] <tt>.init6</tt> ausgeführt, die Destruktoren in <tt>.fini6</tt>.

=Code-Beispiele=
Dieser Abschnitt enthält Code-Schnippsel für avr-gcc. Es werden Besonderheiten besprochen, die für avr-gcc zu beachten sind.

Dieser Abschnitt ist ''kein'' [[C-Tutorial|Tutorial zur C-Programmierung]] und ''keine'' Einführung in die Programmiersprache C im allgemeinen. Dafür sei auf einschlägige Tutorials/Bücher verwiesen.

==Zugriff auf Special Function Registers (SFRs)==

===Zugiff auf Bytes und Worte===
For dem Zugriff auf die SFRs gibt es Defines über den Include
#include <avr/io.h>
Abhängig vom eingestellten Controller werden denn Defines eingebunden, über die auf SFRs wie auf normale Variablen zugegriffen werden kann. Die Namen der Defines sind i.d.R. die gleichen wie im AVR-Manual, also z.b. <tt>SREG</tt> für das Prozessorstatus-Register SREG:
#include <avr/io.h>

...
{{ccomment|SREG lesen}}
uint8_t sreg = SREG;
...
{{ccomment|SREG schreiben}}
SREG = sreg;

Für einen Überblick über die eingebundenen Defines und kann ein Blick in den Controller-spezifischen Header hilfreich sein. Dieser befindet sich in
:<tt> <GCC_HOME>/avr/include/avr/io****.h</tt>
z.B. <tt>iom32.h</tt> für einen [[ATmega32]].

Dieser Zugriff geht auch für 16-Bit Register wie <tt>TCNT1</tt>, für die eine bestimmte Reihenfolge für den Zugriff auf Low- und High-Teil eingehalten werden muss: avr-gcc generiert die Zugriffe in der richtigen Reihenfolge.
uint16_t tcnt1 = TCNT1;

{{FarbigerRahmen|
Zu beachten ist, daß dieser Zugriff nicht atomar erfolgt. Das Lesen/Schreiben mehrbytiger Werte muss vom Compiler in mehrere Byte-Zugriffe zerlegt werden. Zwischen diesen Zugriffen kann ein [[Interrupt]] auftreten, wenn Interrupts aktiviert sind. Je nach Programm und welche Aufgaben eine [[ISR]] erledigt, kann dies zu Fehlfunktion führen. In dem Fall müssen diese Code-Stücke atomar gemacht werden, damit sie nicht durch einen [[IRQ]] unterbrochen werden können!
}}

===Zugriff auf einzelne Bits===
Zugriff auf Bits geht wie gewohnt mit den Bitoperationen
<tt>&</tt> (and),
<tt>|</tt> (or),
<tt>^</tt> (xor) und
<tt>~</tt> (not)

Wieder gibt es Defines in den AVR-Headern, mit denen man Masken für den Zugriff erhalten kann, etwa:
<pre>
/* GIMSK / GICR */
#define INT1 7
#define INT0 6
#define IVSEL 1
#define IVCE 0
</pre>

Masken ergeben sich durch Schieben von <tt>1</tt> an die richtige Position:
<pre>
// Ports B_0 und B_1 als Ausgang
DDRB |= (1<<PB0) | (1<<PB1);
</pre>
erzeugt
<pre>
87 b3 in r24, 0x17
83 60 ori r24, 0x03
87 bb out 0x17, r24
</pre>

Etwas anders sieht der Code aus, wenn die Bits einzeln gesetzt werden und das Register im bitadressierbaren Bereich liegt (SRAM <tt>0x20</tt> bis <tt>0x3f</tt> resp. I/O <tt>0x0</tt> bis <tt>0x1f</tt>):
<pre>
// Ports B_0 und B_1 als Ausgang
DDRB |= (1<<PB0);
DDRB |= (1<<PB1);
</pre>
erzeugt
<pre>
b8 9a sbi 0x17, 0
b9 9a sbi 0x17, 1
</pre>

Um Bits zu löschen, erzeugt man eine Maske, die an der betreffenden Stelle eine  0 hat:
<pre>
// Ports B_2 als Eingang
DDRB &= ~(1<<PB2);
</pre>

{{FarbigerRahmen|
Auch hier ist zu beachten, daß es Probleme geben kann, wenn nicht atomarer Code erzeugt wird, weil der AVR-Befehlssatz nicht mehr hergibt:
<pre>
// toggle PORT B_0: wechseln 0 <--> 1
PORTB ^= (1<<PB0);
</pre>
ergibt
<pre>
88 b3 in r24, 0x18
; Wenn hier ein Interrupt auftritt, in dessen ISR PORTB verändert wird,
; dann wird die Änderung durch die letzte Instruktion wieder überschrieben!
91 e0 ldi r25, 0x01
; dito
89 27 eor r24, r25
; dito
88 bb out 0x18, r24
</pre>
}} 

Auch das Lesen einzelner Port-Pins geht über das Maskieren von SFRs:
<pre>
DDRB &= ~(1 << PB2); // PortB.2 als INPUT

if (PINB & (1 << PB2))
// PortB.2 ist HIGH
else
// PortB.2 ist LOW

if (!(PINB & (1 << PB2)))
// PortB.2 ist LOW
else
// PortB.2 ist HIGH
</pre>

==Interrupts==

Um zu kennzeichnen, daß es sich bei einer Funktion um eine Interrupt Sevice Routine (ISR) handelt, gibt es spezielle Attribute. Diese brauchen nicht explizit hingeschrieben zu werden, ebensowenig wie die genaue Nummer des Interrupt Requests (IRQ). Dafür gibt es Includes und die folgenden Makros.

Bitte beachte auch die Hinweise zu den [[#Inkompatibilität|Inkompatibilität]]en von avr-gcc!
#include <avr/io.h>
#include <avr/interrupt.h>

{{ccomment|Eine nichtunterbrechbare Interrupt-Service-Routine}}
SIGNAL (SIG_OUTPUT_COMPARE1A)
{
{{ccomment|ISR-Code}}
}

{{ccomment|Eine unterbrechbare Interrupt-Service-Routine}}
INTERRUPT (SIG_OUTPUT_COMPARE1B)
{
{{ccomment|ISR-Code}}
}

Dadurch wird die Funktion mit dem richtigen Prolog/Epilog erzeugt, und es wird ein Eintrag in die Interrupt-Vektortabelle gemacht bei obigem Beispiel also zwei Einträge.

{{FarbigerRahmen|
Die Schreibweise des Signal-Names muss genau die sein wie im Header, das schliesst auch Leerzeichen ein! Nicht alle GCC-Versionen bringen Fehler/Warnung, wenn die Schreibweise nicht stimmt.
SIGNAL (SIG_OUTPUT_COMPARE1A ) // !!! Macht NICHT das, was man will (Blank am Ende)!!!
}}

;<tt>SIGNAL</tt>: Mit Ausführung einer ISR deaktiviert die AVR-Hardware die Interrupts, so daß die ISR nicht durch andere Interrupt-Anforderungen unterbrochen wird. Beim Verlassen der ISR werden Interrupts wieder automatisch aktiviert. Tritt während der ISR ein IRQ auf, wird diese erst nach Beenden des ISR-Codes ausgeführt. Der Interrupt geht also nicht verloren. Zwischen zwei ISRs wird zusätzlich mindestens ein Befehl des normalen Programm-Codes abgearbeitet.
;<tt>INTERRUPT</tt>: Früh im ISR-Prolog werden mit <tt>sei</tt> die von der AVR-Hardware temporär deaktivierten Interrupts reaktiviert. Dadurch kann die ISR von einer IRQ unterbrochen werden. Das bietet die Möglichkeit, so etwas wie Interrupt-Priorisierung nachzubilden, was AVRs selbst nicht können. Weiterhin kann man schneller auf bestimmte Ereignisse reagieren. Tritt während der ISR ein anderer IRQ auf, der schnell bedient werden muss, kann sofort der dringende ISR-Code ausgeführt werden. Ansonsten (Verwendung von <tt>SIGNAL</tt>) würde der Code erst ausgeführt werden, nachdem die aktuelle ISR beendet ist.

{{FarbigerRahmen|Dauert die ISR zu lange und wird sie nochmals von ihrem eigenen IRQ unterbrochen, stürzt man ab.}}

Nachschlagen kann man den Namen in
:<tt><GCC_HOME>/avr/include/avr/ioxxxx.h</tt>

===Interrupts aktivieren===

Damit eine ISR überhaupt zur Ausführung kommt, müssen drei Bedingungen erfüllt sein
* Interrupts müssen global aktiviert sein
* Der entsprechen IRQ muss aktiviert worden sein
* Das zum IRQ gehörende Ereignis muss eintreten
#include <avr/io.h>
#include <avr/interrupt.h>

...
{{ccomment|enable OutputCompareA Interrupt für Timer1}}
TIMSK |= (1 << OCIE1A);

{{ccomment|disable OutputCompareA Interrupt für Timer1}}
TIMSK &= ~(1 << OCIE1A);

{{ccomment|Interrupts aktivieren}}
sei();

{{ccomment|Interrupts abschalten}}
cli();
Sperrt man eine Code-Sequenz durch Einschachteln in ein <tt>cli</tt>/<tt>sei</tt> Paar (man macht das Codestück "atomar", also ununterbrechbar), gehen währenddessen keine Interrupt-Anforderungen verloren. Die entsprechenden IRQ-Flags bleiben gesetzt, und nach dem <tt>sei</tt> werden die IRQs in der Reihenfolge ihrer Prioritäten abgearbeitet. Ausnahme ist, wenn in einem atomaren Block der selbe IRQ mehrfach auftritt. Der ISR-Code wird dann trotzdem nur einmal ausgeführt.

===default Interrupt===

Für nicht implementierte Interrupts macht avr-gcc in die Vektortabelle einen Eintrag,
der zu <tt>__bad_interrupt</tt> (definiert im Startup-Code <tt>crt*.o</tt>) springt
und von dort aus weiter zu Adresse 0.
Dadurch läuft der AVR wieder von neuem los, wenn ein Interrupt auftritt,
zu dem man keine ISR definiert hat
 allerdings ohne die Hardware zurückzusetzen wie bei einem echten Reset.

Möchte man diesen Fall abfangen, dann geht das über eine globale Funktion
namens <tt>__vector_default</tt>:
<pre>
#include <avr/interrupt.h>

SIGNAL (__vector_default)
...
</pre>
Damit wird von <tt>__bad_interrupt</tt> aus nicht nach Adresse 0 gesprungen,
sondern weiter zu <tt>__vector_default</tt>, welches durch <tt>SIGNAL</tt> oder
<tt>INTERRUPT</tt> den üblichen ISR-Prolog/Epilog bekommt.

So kann man z.B. eine Meldung ausgeben, eine Warnlampe blinken, in einer Endlosschleife landen, oder über den [[Watchdog]] einen richtigen Hardware-Reset auslösen, siehe auch Abschnitt "[[#Reset auslösen|Reset auslösen]]".

===ISR mit eigenem Prolog/Epilog===

Wenn man in einer ISR komplett eigenes Zeug machen will,
dann definiert man eine nackte Funktion.
Mit <tt>naked</tt> befreit man die Routine vom Standard-Prolog/Epilog.
{{FarbigerRahmen|
Dabei ist darauf zu achten, daß die ISR mit <tt>reti</tt> (return from interrupt)
zurückkehrt und evtl. verwendete Register und den Status (<tt>SREG</tt>) sichert.
}}
#include <avr/io.h>

void __attribute__ ((naked))
SIG_OVERFLOW0 (void)
{
{{ccomment|Port B.6 = 0}}
{{ccomment|Diese Instruktion verändert nicht das SREG und kein anderes Register}}
{{ccomment|so daß der eigentliche Code nur 1 Befehl lang ist}}
__asm__ __volatile (
"cbi %0, %1" "\n\t"
"reti"
:
: "M" (_SFR_IO_ADDR (PORTB)), "i" (6)
);
}

Siehe auch [[Inline-Assembler in avr-gcc]].
Die ISR sieht dann so aus:
<pre>
__vector_9:
c6 98 cbi 0x18, 6
18 95 reti
</pre>

Wiederum kann man als Funktionsname <tt>__vector_default</tt> nehmen,
um nicht-implementierte IRQs abzufangen:
<pre>
void __attribute__ ((naked))
__vector_default (void)
...
</pre>

==SRAM, Flash, EEPROM: Datenablage am Beispiel Strings==
Die Programmiersprache C kennt selber keine Strings; das einzige, was C bekannt ist, ist der Datentyp <tt>char</tt>, der ein einzelnes Zeichen repräsentiert.
===Darstellung in C===
Ein String im Sinne von C ist ein Array von Charactern bzw. ein Zeiger auf den Anfang des Arrays. Die einzelnen Zeichen folgen im Speicher direkt aufeinander und werden in aufsteigenden Adressen gespeichert. Am String-Ende folgt als Abschluss der Character <tt>'\0'</tt>, um das Ende zu kennzeichnen. Dies ist besonders bei der Berechnung des Speicherplatzes für Strings zu berücksichtigen, denn für die 0 muss auch Platz reserviert werden.

===Bestimmen der Stringlänge===
<pre>
/* Bestimmt die Laenge des Strings ohne die abschliessende '\0' zu zaehlen */
unsigned int strlength (const char *str)
{
unsigned int len = 0;

while (*str++)
len++;

return len;
}
</pre>

Die Stringlänge kann auch mit der Standard-Funktion <tt>strlen</tt> bestimmt werden, deren Prototyp sich in <tt>string.h</tt> befindet:
<pre>
#include <string.h>
size_t strlen (const char*);
</pre>

===String im Flash belassen===
Oftmals werden Strings nur zu Ausgabezwecken verwendet und nicht verändert. Verwendet man Sequenzen der Gestalt
<pre>
char *str1 = "Hallo Welt!";
char str2[] = "Hallo Welt!";
</pre>
dann werden die Strings im SRAM abgelegt. Im Startup-Code werden die Strings vom Flash ins SRAM kopiert und belegen daher sowohl Platz im SRAM als auch im Flash. Wird ein String nicht verändert, braucht er nicht ins SRAM kopiert zu werden. Das spart Platz im knapp bemessenen SRAM. Allerdings muss anders auf den String zugegriffen werden, denn wegen der Harvard-Architektur des AVR-Kerns kann avr-gcc anhand der Adresse nicht unterscheiden, ob diese ins SRAM, ins Flash oder ins EEPROM zeigt.
<pre>
#include <avr/pgmspace.h>

const prog_char str3[] = "Hallo Welt!";

unsigned int strlen_P (const prog_char *str)
{
unsigned int len = 0;

while (1)
{
char c = (char) pgm_read_byte (str);
if ('\0' == c)
return len;
len++;
str++;
}
}

void foo()
{
unsigned int len;
len = strlen_P (str3);
len = strlen_P (PSTR("String im Flash"));
}
</pre>

===String ins EEPROM legen===
Dies geht nach dem gleichen Muster, nach dem Strings ins Flash gelegt werden. Der Zugriff wird vergleichsweise langsam, denn der EEPROM ist langsamer als SRAM bzw. Flash.
<pre>
#include <avr/eeprom.h>

const char str4[] __attribute__ ((section(".eeprom"))) = "Hallo Welt!";

unsigned int strlen_EE (const char *str)
{
unsigned int len = 0;

while (1)
{
char c = (char) eeprom_read_byte (str);
if ('\0' == c)
return len;
len++;
str++;
}
}
</pre>

==Reset auslösen==
Falls ein Reset per Software ausgelöst werden soll, dann geht das am besten über den [[Watchdog]].
Einfach nur an den RESET-Punkt an Adresse 0 zu springen mit
goto *((void**) 0);
initialisiert zwar den Controller von neuem, aber es macht keinen wirkliches RESET mit Zurücksetzen der Hardware und allen I/O-Registern.

Durch den Watchdog kann man ein 'richtiges' RESET-Signal erzeugen lassen, so daß die AVR-Hardware genau so initialisiert ist, wie nach einem externen RESET. So kann man z.B. via [[UART]] ein RESET-Kommando schicken. Allerdings lässt sich der Watchdog nur minimal auf 15ms einstellen:

#include <avr/wdt.h>
#include <avr/interrupt.h>
...
cli(); {{ccomment|Interrupts global abschalten}}
wdt_enable (WDTO_15MS); {{ccomment|Watchdog aufziehen auf 15ms}}
while (1); {{ccomment|warten, bis er zubeisst...}}

Welches Ereignis einen RESET ausgelöst hat, kann man im Register '''MCUCSR''' (''MCU Control and Status Register'') erfahren. Es gibt 4 mögliche RESET-Quellen:
* Power-On Reset
* External Reset
* Brown-Out Reset
* Watchdog Reset

Soll der Inhalt von Variablen einen Reset überleben – eine Variable also nicht initialisiert werden – dann geht das so:
#include <avr/io.h>

{{ccomment| status informiert z.B. darüber, ob wir selber den Watchdog ausgelöst haben }}
{{ccomment| oder nicht, oder andere Informationen }}
unsigned char status __attribute__ ((section (".noinit")));

void main (void)
{
{{ccomment|Wert von MCUSCR merken, möglichst früh im Programm }}
unsigned char mcucsr = MCUCSR;

{{ccomment|MCUCSR zurücksetzen }}
MCUCSR = 0;

{{ccomment|Watchdog-Reset }}
if (mcuscr & (1 << WDRF))
{
{{ccomment|status auswerten }}
}

{{ccomment|Power-On Reset: status auf definierten Wert setzen }}
if (mcuscr & (1 << PORF))
{
status = 0;
}

{{ccomment|status auswerten }}
...
}

=Includes=

Die mit
#include <...>
angegebenen Includes werden von avr-gcc in den
mit der Option '<tt>-I</tt>' anegegenen Pfaden gesucht.
Dem Compiler bekannt sind die Pfade
<GCC_HOME>/avr/include Standard (stdio.h, ...)
<GCC_HOME>/avr/include/avr AVR-spezifisch (avr/io.h, ...)
<GCC_HOME>/lib/gcc/avr/<GCC_VERSION>/include Standard, compilerabh. (limits.h, ...)

Gibt man z.B. an
#include <stdio.h>
dann wird automatisch in diesem Verzeichnis nach <tt>stdio.h</tt> gesucht.
In den Verzeichnissen stehen Standard-Includes, die benötigt werden, wenn man libc-Funktionen
oder mathematische Funktionen etc. verwendet.
AVR-spezifische Dinge stehen im Unterverzeichnis <tt>avr</tt>, etwa:
#include <avr/io.h>
{{FarbigerRahmen|
Als Pfad-Separator wird immer ein '''<tt>/</tt>''' verwendet, auch auf Windows-Betriebssystemen! Also kein '''<tt>\</tt>''' !
}}

==Standard==

ctype.h Zeichen-Umwandlungs-Makros und ctype Makros
errno.h Symbolische Namen für Fehlercodes
inttypes.h Definiert [u]intN_t wenn man genau N [un]signed Bits
braucht, ISO C99.
math.h Mathematische Funktionen: sin, cos, log, gamma, bessel, ...
setjmp.h libc unterstützt setjmp() und longjmp(), um direkt in eine
andere (nicht-lokale) Funktion zu springen.
stdio.h Standard I/O-Funktionen (printf, ...).
stdlib.h Deklariert grundlegende ISO C-Makros und -Funktionen
sowie einige AVR-spezifische Erweiterungen
string.h Stringoperationen auf NULL-terminierten Strings. (strlen, ...)
stdarg.h Funktionen mit variabler Argumenanzahl
limits.h Min- und Max-Werte von Skalaren (UCHAR_MAX, LONG_MIN, ...)

==AVR-spezifisch==

Die AVR-spezifischen Includes finden sich wie gesagt im Unterverzeichnis <tt>avr</tt>.
Die meisten dort befindlichen Header wird man nie direkt durch Angabe im C-File erhalten,
sondern durch Angabe von
#include <avr/io.h>
Dadurch werden z.B. genau die I/O-Header eingebunden, die zum AVR-Modell passen, also
*<tt>avr/iom8.h</tt> für [[ATmega8]],
*<tt>avr/iotn2313.h</tt> für [[ATtiny2313]],
*<tt>avr/io2313.h</tt> für [[AT90S2313]], etc.

Verantwortlich dafür ist der Schalter '<tt>-mmcu=xxx</tt>'.

Obwohl diese Header nicht explizit angegeben werden müssen,
kann ein Blick dorthin hilfreich sein, um die Namen von [[SFR|SFRs]]
oder Signals nachzuschlagen.
Diese Header werden im folgenden nicht alle einzeln aufgelistet.
Ihre Namen sind immer <tt>avr/io*.h</tt>.
* für ATmega: <tt>avr/iom*.h</tt>
* für ATtiny: <tt>avr/iotn*.h</tt>
<pre>
avr/boot.h Bootloader Support
avr/crc16.h [*] Prüfsumme CRC16
avr/delay.h [*] Verzögerungsschleifen für kurze, exakte Verzögerungen
avr/eeprom.h EEPROM-Routinen
avr/ina90.h Kompatibilität mit IAR-AVR-Compiler
avr/interrupt.h sei(), cli(), ...
avr/io.h --> inttypes.h, io*.h
avr/io*.h SFRs, SIG_****, SPM_PAGESIZE, RAMEND, XRAMEND, E2END, FLASHEND
avr/parity.h [*] Parität
avr/pgmspace.h Zugriff aufs Flash: Byte lesen, PROGMEM, prog_char, prog_uint8_t, ...
avr/portpins.h Makros für Port-Pins
avr/signal.h [**] Makros SIGNAL() und INTERRUPT(), ...
avr/sleep.h Power-Safe
avr/twi.h [*] I2C
avr/wdt.h Watchdog

util/crc16.h Prüfsumme CRC16
util/delay.h Verzögerungsschleifen für kurze, exakte Verzögerungen
util/parity.h Parität
util/twi.h I2C

[*] bei neueren avr-gcc-Versionen in util
[**] entfällt bei neueren avr-gcc-Versionen. Stattdessen avr/interrupt.h verwenden
</pre>

==Anwendungs-spezifisch==
Eigene Header, die nur innerhalb eigener Projekte gebraucht werden, includet man mit
#include "..."
Auch hier darf man Unterverzeichnisse angeben oder ins übergeordnete Verzeichnis:
#include "../../mein-zeug.h"

=Optimierungen, Tipps & Tricks=

Beim Programmieren in C möchte man sich möglichst wenig mit der Codeerzeugung selbst auseinandersetzen. Man verwendet ja gerade deshalb einen Compiler und programmiert nicht in Assembler, weil man sich nicht um Register-Belegungen o.ä. kümmern will, sondern nur um die zu lösende Aufgabe.

GCC erzeugt zwar recht guten Code, aber er ist nicht perfekt. Gerade auf Systemen wie AVR mit nur sehr begrenzten Resourcen muss man daher dem Compiler hilfreich zur Seite stehen, wenn man noch dichteren/schnelleren Code erhalten möchte.

:''"Unlike most other C compilers, GCC allows you to use -g with -O. The shortcuts taken by optimized code may occasionally produce surprising results: some variables you declared may not exist at all; flow of control may briefly move where you did not expect it; some statements may not be executed because they compute constant results or their values were already at hand; some statements may execute in different places because they were moved out of loops.''

:''Nevertheless it proves possible to debug optimized output. This makes it reasonable to use the optimizer for programs that might have bugs."''

Um das Ergebnis zu beurteilen, hilft ein Blick ins Listfile.
Siehe dazu auch die Abschnitte
"[[Hallo Welt für AVR (LED blinken)#Listfile erstellen|Listfile erstellen]]"
und
"[[Hallo Welt für AVR (LED blinken)#Die Größe ermitteln|Die Größe ermitteln]]"
im [[Hallo Welt für AVR (LED blinken)|Hallo Welt für AVR]].

==Optimierungsgrad==
Als Optimierungsgrad erweist sich <tt>-Os</tt> (Optimize for Size) als der beste, evtl. noch <tt>-O2</tt>. Ohne Angabe eines Optimierungsgrades wird nicht optimiert, was gleichbedeutend mit der Option <tt>-O0</tt> ist. Abzuraten ist von der maximalen Optimierung <tt>-O3</tt>, die wegen function inlining und loop unrolling zu sehr breitem Code führt und für AVR absolut nicht angesagt ist.

==Vermeide printf, scanf, malloc==
Funktionen von diesem Kaliber sind die absoluten Platz- und Zeitfresser.

Alternativen findet man reichlich in der <tt>avr-libc</tt> wie <tt>itoa</tt> und <tt>atoi</tt>.
Und für <tt>malloc</tt> und Konsorten sind dynamische Arrays und das Compiler-Builtin <tt>__builtin_alloca</tt> effizientere Alternativen, siehe auch im Abschnitt "[[avr-gcc#Dynamische Speicherallokierung|Dynamische Speicherallokierung]]".

==Konstante Strings ins Flash==
Konstante Strings, wie sie zu Ausgabezwecken Verwendung finden, werden im Programm oft nicht verändert und brauchen nicht SRAM zu belegen (und damit auch Flash, von wo aus sie vom Startup-Code ins SRAM kopiert werden), sondern gehören ins Flash!

Entsprechende Routinen, um auf Strings im Flash zuzugreifen, tragen die Suffix <tt>_P</tt>, wie z.B. <tt>strcmp_P</tt> mit dem Prototyp
extern int *strcmp_P (char *, const prog_char *)
Die Implementierungen befinden sich in der <tt>avr-libc</tt>.

'''Anwendung:'''
#include <avr/pgmspace.h>

const prog_char str_p[] = "Ein String im Flash";
const char str2_p[] PROGMEM = "Noch ein String im Flash";
...
{{ccomment|String im SRAM mit String im Flash vergleichen}}
if (!strcmp_P (str_sram, str_p))
{
{{ccomment|mach was bei Gleichheit}}
}

{{ccomment|"foo" wird im RAM angelegt. Ineffizient für konstante Strings!}}
{{ccomment|Beachte, daß damit strcmp (nicht strcmp_P) benutzt werden muss.}}
if (!strcmp (str_sram, "foo"))
{
{{ccomment|mach was bei Gleichheit}}
}

{{ccomment|PSTR bewirkt, daß die String-Konstante "foo"}}
{{ccomment|im Flash angelegt wird}}
if (!strcmp_P (str_sram, PSTR ("foo"))
{
{{ccomment|mach was bei Gleichheit}}
}
...
}

===Sprungtabelle===
Genauso macht man auch eine Sprungtabelle, um anhand von Kommando-Strings dazugehörige Funktionen ausführen zu lassen:
#include <avr/pgmspace.h>

int func1 (int arg)
{
...
}

#define TEXT_LEN 15

{{ccomment|Die Kommandostruktur}}
typedef struct
{
int (*func)(int); {{ccomment|Zeiger auf die auszuführende Funktion}}
int arg; {{ccomment|das Argument, das mitübergeben wird}}
char text[1+TEXT_LEN]; {{ccomment|Text, maximal TEXT_LEN Zeichen lang}}
} command_t;

{{ccomment|Das Array mit den Kommandos.}}
{{ccomment|Die funcx sind vom Prototyp (z.B. func1 oben)}}
{{ccomment|int funcx (int arg);}}
const command_t commands[] PROGMEM =
{
{ func1, 0, "Befehl 1" },
{ func2, 3, "Befehl für func2" }
};

{{ccomment|Sucht in commands[] nach text und führt gegebenenfalls}}
{{ccomment|die dazugehörige Funktion funcx mit Argument arg aus.}}
{{ccomment|Liefert den Rückgabewert von funcx}}
{{ccomment|oder -1, falls text nicht gefunden wurde.}}
int execute (const char *text)
{
{{ccomment|Schleifenvariable}}
unsigned char i;

{{ccomment|Wandert durch das Array mit Kommando-Strukturen}}
const command_t * cmd = commands;

{{ccomment|sizeof wird von gcc ausgewertet und ist wie eine Konstante,}}
{{ccomment|denn beide sizeofs sind zur Compilezeit bekannt}}
for (i=0; i < sizeof(commands) / sizeof(command_t); i++)
{
{{ccomment|Ist das der gesuchte String?}}
if (strcmp_P (text, cmd->text))
{
{{ccomment|Nein, dann weitersuchen}}
cmd++;
continue;
}

{{ccomment|Ja}}
int (*func)(int), arg;

{{ccomment|Dann Funktionszeiger und Argument besorgen,}}
func = (int(*)(int)) pgm_read_word (& cmd->func);
arg = (int) pgm_read_word (& cmd->arg);

{{ccomment|Funktion ausführen und deren Wert zurückliefern}}
return func (arg);
}

{{ccomment|text ist nicht in commands}}
return -1;
}

Nachteil dabei ist, daß jeder String den maximalen Platz von <tt>TEXT_LEN+1</tt> Zeichen belegt.
Falls man da noch weiter sparen will, dann kann man die Strings wieder ins Flash legen und ihre Adresse in der Struktur merken. Dadurch belegt ein String nur noch Länge+3 Zeichen (+3 wegen 1 Endezeichen und 2 Bytes für seine in der Struktur gemerkte Adresse). Die Definition der Tabelle wird aber umständlicher, weil jeder String einzeln angegeben werden muss:
#include <avr/pgmspace.h>

{{ccomment|Die Kommandostruktur}}
typedef struct
{
...
char * text; {{ccomment|Zeiger auf Text}}
} command_t;

const prog_char str_1[] = "Befehl 1";
const prog_char str_2[] = "Befehl für func2";

const command_t commands[] PROGMEM =
{
{ func1, 0, str_1 },
{ func2, 3, str_2 }
};

{{ccomment|Sucht in commands[] nach text und führt gegebenenfalls}}
{{ccomment|die dazugehörige Funktion funcx mit Argument arg aus.}}
{{ccomment|Liefert den Rückgabewert von funcx}}
{{ccomment|oder -1, falls text nicht gefunden wurde.}}
int execute (const char *text)
{
{{ccomment|Schleifenvariable}}
unsigned char i;

{{ccomment|Wandert durch das Array mit Kommando-Strukturen}}
const command_t * cmd = commands;

{{ccomment|sizeof wird von gcc ausgewertet und ist wie eine Konstante,}}
{{ccomment|denn beide sizeofs sind zur Compilezeit bekannt}}
for (i=0; i < sizeof(commands) / sizeof (command_t); i++)
{
const prog_char * text_P;

{{ccomment|Liest die Startadresse von str_x}}
text_P = (const prog_char *) pgm_read_word (& cmd->text);

{{ccomment|Ist das der gesuchte String?}}
if (strcmp_P (text, text_P))
{
...

==Lokale Variablen verwenden==

Beim Manipulieren globaler Variablen kann es günstig sein, diese in eine lokale Variable zu kopieren, dort zu verändern, und sie danach wieder zu schreiben
<pre>
char var;

void foo1()
{
var++;
if (var > 10)
var = 1;
}
</pre>
Dadurch wird einmal unnötig gespeichert (der dritte Befehl kann vermieden werden).
<pre>
foo1:
lds r24,var ; *movqi/4 [length = 2]
subi r24,lo8(-(1)) ; addqi3/2 [length = 1]
sts var,r24 ; *movqi/3 [length = 2]
cpi r24,lo8(11) ; cmpqi/2 [length = 1]
brlt .L3 ; branch [length = 1]
ldi r24,lo8(1) ; *movqi/2 [length = 1]
sts var,r24 ; *movqi/3 [length = 2]
.L3:
ret
</pre>
Indem man eine lokale Variable (<tt>var2</tt>) verwendet für die Änderung von <tt>var</tt> vermeidet man dies:
<pre>
char var;

void foo2()
{
char var2 = var;

var2++;
if (var2 > 10)
var2 = 1;

var = var2;
}
</pre>
Dadurch wird erst am Ende gespeichert. <tt>var2</tt> lebt in Register <tt>r24</tt>.
<pre>
foo2:
lds r24, var ; *movqi/4 [length = 2]
subi r24,lo8(-(1)) ; addqi3/2 [length = 1]
cpi r24,lo8(11) ; cmpqi/2 [length = 1]
brlt .L2 ; branch [length = 1]
ldi r24,lo8(1) ; *movqi/2 [length = 1]
.L2:
sts var, r24 ; *movqi/3 [length = 2]
ret
</pre>

Bei diesem einfachen Beispiel spart man lediglich eine Instruktion. Bei komplexeren Rechnungen oder längeren Datentypen kann es aber durchaus lohnender sein, in lokale Register zu kopieren.

==Arithmetik==

=== Daten zerlegen/zusammensetzen ===

In systemnahen Programmen hat man oft was Problem, auf die einzelnen Bytes oder Bitfelder einer grösseren Datenstruktur zuzugreifen. Indem man sich ein Komposit baut, das die gewünschten Strukturen überlagert, kann man effizient z.B. auf Bytes zugreifen. Ausnahme sind Bitfelder, deren Verwendung etwas breiten Code ergibt. Bitfelder "von Hand" zu manipulieren, ist da manchmal effizienter, führt jedoch zu schlecht lesbarem Code.

Oft benötigt wird der Zugriff auf die einzelnen Bytes eines <tt>int</tt>, also der Zugriff auf die Bytes eines 16-Bit-Wertes:

typedef union
{
unsigned char asByte[2];
unsigned short asWord;
int asInt;
} data16_t;

data16_t data;
...
int foo;
uint8_t wert;

data.asInt = foo;
wert = data.asByte[1]; {{ccomment|die oberen 8 Bits von foo}}

Ein komplexeres Beispiel, das noch mehr Datentypen überlagert:
typedef ... foo_t;

typedef union
{
unsigned char byte[4]; {{ccomment| Zugriff als Bytes (8 Bit) }}
unsigned short word[2]; {{ccomment| Zugriff als Words (16 Bit) }}
signed long slong; {{ccomment| Zugriff als signed long (32 Bit) }}

struct {{ccomment| Zugriff auf einzelne Bitgruppen }}
{
unsigned bit_0_3 : 4; {{ccomment| 4 Bits (0..3) }}
unsigned bit_4_8 : 5; {{ccomment| 5 Bits (4..8) }}
unsigned bit_9_21 : 13; {{ccomment| 13 Bits (9..21) }}
unsigned bit_22_31: 10; {{ccomment| 10 Bits (22..31) }}
};

foo_t foo; {{ccomment| Zugriff als foo-Struktur }}
} data_t;

...
{
data_t data;

data.byte[2] = 12; {{ccomment| setzt byte 2 auf 12 }}
data.bit_4_8 = 0x1f; {{ccomment| setzt bits 4..8 (5 Stück) alle auf 1 }}

int anInt = data.foo.anInt; {{ccomment| liest ein Feld von foo (hier ein int) }}
...
}

===libgcc2 verwenden===

In der libgcc2 sind einige Arithmetik-Routinen in Assembler implementiert. Dazu gehören ein paar Algorithmen zu Division (mit Rest) und Multiplikation.

Von diesen Algorithmen werden durch die avr-libc jedoch nur zwei Strukturen und Funktionen veröffentlicht: <tt>div_t</tt> und <tt>ldiv_t</tt> resp. die Funktionen <tt>div()</tt> und <tt>ldiv()</tt>. Siehe dazu deine Dokumentation zur avr-libc. Damit kann man Quotient und zusätzlich den Rest bei einer Division 16/16 bzw. 32/32 berechnen lassen; den Rest bekommt man quasi kostenlos als Nebenprodukt. Das ist praktisch, wenn man z.b. eine Zahl in Dezimaldarstellung umwandeln möchte oder von/nach [[BCD]].

Zusätzlich zu den via avr-libc veröffentlichten Funktionen gibt es aber noch Routinen, die z.B. auf 8-Bit-Werten operieren oder mit <tt>unsigned</tt> Typen und dementsprechend effizienter sind.

'''Beispiel: Umwandeln nach Dezimalstring'''

Hier ein Beispiel, das Division mit Rest für <tt>unsigned short</tt> verwendet, um eine 16-Bit-Zahl in Dezimaldarstellung zu wandeln:

{{ccomment| Struktur definieren und Funktion bekannt machen }}
typedef struct
{
unsigned short quot;
unsigned short rem;
} udiv_t;

extern udiv_t udiv (unsigned short, unsigned short) __asm__("__udivmodhi4");

{{ccomment| 5 Ziffern (0...65535) und evtl. noch eine führende 0 }}
#define DIGITS 6

{{ccomment| +1 wegen String-Ende (wird im Startup auf 0 gesetzt) }}
char string[DIGITS+1];

{{ccomment| Wandelt zahl in Dezimaldarstellung um. }}
{{ccomment| Der return-Wert zeigt irgendwo ins string[]-Array. }}
{{ccomment| string[] wird verändert. }}
char* toString (unsigned short zahl)
{
{{ccomment| s zeigt auf das Ende von string }}
{{ccomment| string wird von hinten nach vorne gefüllt }}
char *s = string + DIGITS;

{{ccomment| qrem enthält Quotient (quot) und Rest (rem) der Divisionen }}
udiv_t qrem = {.quot = zahl};

do
{
{{ccomment| Division mit Rest durch 10 }}
{{ccomment| quot: Ergebnis für den nächsten Durchlauf }}
{{ccomment| rem: Rest ist die Ziffer im 10er-System }}
qrem = udiv (qrem.quot, 10);

{{ccomment| Ziffer in Zeichen wandeln und speichern }}
*(--s) = '0' + qrem.rem;
}
while (0 != qrem.quot);

{{ccomment| Falls eine führende '0' gespeichert wurde: weg damit }}
{{ccomment| ausser zahl war selbst schon 0 }}
if (*s == '0' && *(s+1) != '\0')
s++;

return s;
}

Falls man eine Division und/oder Rest für 8-Bit braucht, dann geht für <tt>unsigned</tt> analog.

'''Beispiel: BCD-Umrechnung'''

Wandeln einer 8-Bit-Zahl <tt>0 <= num < 100</tt> nach [[BCD]]

typedef struct
{
unsigned char quot; {{ccomment| Quotient }}
unsigned char rem; {{ccomment| Rest (remainder) }}
} udiv8_t;

extern udiv8_t udiv8 (unsigned char, unsigned char) __asm__ ("__udivmodqi4");

{{ccomment| Wandelt num nach BCD um, 0 <= num <= 99 }}
{{ccomment| return-Wert ist dann 0x0 <= return <= 0x99 }}
unsigned char to_bcd (unsigned char num)
{
udiv8_t qrem = udiv8 (num, 10);

return (unsigned char) (qrem.quot << 4) | qrem.rem;
}

===Division durch Multiplikation===
===Vermeiden von float und double===

=Inkompatibilität=

[[GCC]] – und somit auch avr-gcc – werden ständig weiter entwickelt. Dies betrifft das Beheben von Fehlern, die Unterstützung neuer Architekturen/Sprachen/Betriebssysteme, Implementierung neuer Optimierungsalgorithmen, Vereinheitlichungen, etc.

Leider führt dies auch zu Inkompatibilitäten verschiedener avr-gcc-Versionen untereinander, und eine C-Quelle, die mit einer Version von avr-gcc fehler- und warnungsfrei übersetzt werden kann, ist mit einer anderen Version möglicherweise nicht compilierbar.

Die avr-gcc Version kann man anzeigen lassen, indem man in einer Shell/Eingabeaufforderung eintippt
avr-gcc -v

;<tt>#include <avr/signal.h></tt>: In Versionen bis 3.4.4 werden in dieser Header-Datei u.a. die Makros <tt>SIGNAL()</tt> und <tt>INTERRUPT()</tt> definiert, die man braucht, wenn man eine C-Funktion als Interrupt-Routine ([[ISR]]) kennzeichnen will. In neueren Versionen ab 3.4.5 sind diese Definitionen in den Header <tt>avr/interrupt.h</tt> gewandert, wo auch Makros wie <tt>sei()</tt> und <tt>cli()</tt> definiert werden. Die Inkludierung von <tt>avr/signal.h</tt> in den neueren avg-gcc Versionen führt zu einer Warnung, irgendwann vielleicht sogar zu einem Fehler, weil die Datei nicht mehr bei avr-gcc dabei ist und daher nicht mehr gefunden wird.
: '''Verwendet man bei einer älteren avr-gcc-Version <tt>SIGNAL</tt> bzw. <tt>INTERRUPT</tt> ohne <tt>avr/signal.h</tt> zu includen, wird u.U. stillschweigend falscher Code erzeugt.'''

;<tt>#include <util/...h></tt>: In <tt>util</tt> stehen jetzt Header wie <tt>util/parity.h</tt> oder das vielverwendete <tt>util/delay.h</tt>, die vormals im Include-Unterverzeichnis <tt>avr</tt> zu finden waren.

;Interrupt Service Routinen: Auch die API zur Definition von [[ISR]]s hat sich von avr-gcc Version 3.x zur Version 4.x geändert:
:'''avr-gcc 3.x'''
::{|
<pre>
SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

INTERRUPT (SIG_OVERFLOW0)
{
/* Interrupt Code */
}
</pre>
|}

:'''avr-gcc 4.x'''
::{|
<pre>
ISR (INT0_vect)
{
/* Interrupt Code */
}

void TIMER0_OVF_vect (void) __attribute__((interrupt));
void TIMER0_OVF_vect (void)
{
/* Interrupt Code */
}
</pre>
|}

=Bugs=

==== Bit 7 bei SFR-Zugriff ====

Bei Sequenzen wie
PORTB &= ~ (1 << 7);
PORTD &= ~ (1 << 7);

macht avr-gcc eine CSE-Optimierung (common subexpression elimination). Er legt die Konstante 127 (<tt>~(1 << 7)</tt>) in ein Register und verwendet den Registerinhalt, anstatt die Konstante direkt zu verwenden.

Das führt dazu, daß statt der gewünschten Befehlsfolge
; Sequenz 1
cbi 37-0x20, 7
cbi 43-0x20, 7
Sequenzen folgender Gestalt erzeugt werden:
; Sequenz 2
ldi r18, lo8(127) ; 127 nach R18

in r19, 37-0x20 ; PORTB nach R19 lesen
; Wird hier eine ISR ausgeführt, die PORTB verändert, dann wird die
; Änderung mit dem folgenden OUT überschrieben
and r19, r18 ; oberstes Bit löschen
; dito
out 37-0x20, r19 ; PORTB schreiben

in r19, 43-0x20 ; analog
and r19, r18
out 43-0x20, r19

Abgesehen davon, daß Sequenz 2 deutlich mehr Programmspeicher und Laufzeit benötigt als Sequenz 1, kann es zu folgendem Fehler kommen:

Bei der zweiten Codesequenz erfolgt der Zugriff auf die SFRs nicht atomar. Wird der C-Code in einem Programm ausgeführt, das in einer [[ISR]] zB Port B3 verändert und wird diese ISR zwischen dem IN und dem OUT Befehl ausgeführt, dann überschreibt der OUT-Befehl den Wert von PORTB und die Aktion für Port B3 in der ISR wird wieder rückgängig gemacht. Das ist dann ein Programmfehler.

Damit das Problem zum Tragen kommt, müssen mehrere Bedingungen erfüllt sein:
* Bei mindestens zwei C-Befehlen wird der Wert 127 als 8-Bit-Wert benötigt. Das ist zB auch der Fall, wenn dieser Wert nur gespeichert wird oder modulo 0x80 gerechnet wird.
* Mindestens einer dieser Befehle löscht Bit 7 eines SFR aus dem bitadressierbaren I/O-Bereich. (Ausser PORTx oder DDRx sind in diesem Bereich noch weitere SFR untergebracht.)
* Im Programm wird auf unterschiedlichen [[Interrupt]]-Ebenen auf dieses SFR zugegriffen und die oben gezeigt Stelle kann von der ISR unterbrochen werden.
* Die beiden C-Befehle müssen nicht unmittelbar aufeinander folgen. Es können auch andere C-Befehle dazwischen stehen.

Bei den meisten Programmen wird das angesprochene Problem nicht zu einem Fehler führen. Falls doch, kann man dem begegnen mit folgenden

;Workarounds:
* Die C-Stelle wird in CLI/SEI eingeschlossen und kann damit nicht mehr von einer ISR unterbrochen werden.
* Alternativ schreibt man vor und nach jedem problematischen SFR-Zugriff folgendes Kommando:
:{|
|-
|
__asm volatile (""::);
|}
:Dieses Kommando erzeugt keine Assembler-Instruktionen, vermeidet aber die unerwünschte "Optimierung" im gcc, und es entsteht Code gemäß Sequenz 1.
* Alternativ definiert man sich ein Makro, mit dem man die Portzugriffe tätigt:
:{|
|-
|
#define CBI(A,B) __asm volatile ("cbi\t%0, %1" :: "M" (_SFR_IO_ADDR(A)), "M" (B))
|}
:Und löscht das Bit mit
:{|
|-
|
CBI (PORTB, 7);
|}

==== <tt>__builtin_return_address(0)</tt> ====
ist entgegen der Spezifikation nicht implementiert und liefert in der Regel ein falsches Ergebnis.

;Workaround:

(hier für eine ISR):
#include <stdarg.h>
#include <avr/interrupt.h>

{{ccomment|The return address}}
unsigned short volatile return_addr;

{{ccomment|Define our special SIGNAL (INTERRUPT analoguous)}}
#define SIGNAL_BRA(signame,var) \
void signame (unsigned short var, ...) __attribute__ ((signal)); \
void signame (unsigned short var, ...)

#define SWAP_BYTES(x) (((x) >> 8) | ((x) << 8))

SIGNAL_BRA (SIG_OUTPUT_COMPARE1A, dummy)
{
{
va_list vlist;
va_start (vlist, dummy);

{{ccomment|Get the return address from the stack}}
dummy = va_arg (vlist, unsigned short);

{{ccomment|Convert stack address to code location}}
addr = SWAP_BYTES(dummy) << 1;
va_end (vlist);
}
{{ccomment|ISR Code}}
}

==== gcc 4.x ====

In der 4er-Version gab es tiefgreifende interne Änderungen im Compiler; er ist noch instabil und kann momentan nicht für den Produktiv-Einsatz empfohlen werden (Stand 02/2006).

Die Auswirkungen der Optimierungen auf das Zielsystem <tt>avr</tt> bleibt abzuwarten, dürfte aber nicht wesentlich sein. Die neue 4-er Version wurde u.a. deshalb aufgelegt, um mit dem Intel-Compiler gleichzuziehen – also im Hinblick auf das Zielsystem <tt>i386</tt>) gemacht.

Auch nach dem Release der 4-er Version wird die 3-er Version weiterentwickelt, da erst nach 1-2 Jahren nach Release einer neuer Major-Version ein Umstieg anzuraten ist und auch erst dann getätigt wird (zumindest im professionellen Bereich).

=Abkürzungen und Bezeichnungen=
; [[GCC]]: GNU Compiler Collection
; gcc: GNU C-Compiler
; GPR: '''G'''eneral '''P'''urpose '''R'''egister
; [[ISR]]: [[Interrupt|'''I'''nterrupt]] '''S'''ervice '''R'''outine
; [[IRQ]]: '''I'''nterrupt '''R'''e'''q'''uest
; Prolog/Epilog: Code am Anfang/Ende jeder Funktionen/ISR, der dazu dient, verwendete Register zu sichern, den Stack-Frame für lokale [[Variable|Variablen]] anzulegen (falls benötigt), Stackpointer zu setzen, zurück zu springen (<tt>ret</tt>, <tt>reti</tt>), etc.
; SFR: '''S'''pecial '''F'''unction '''R'''egister
; Target: Zielsystem, in unserem Falle avr

=Siehe auch=
* [[C-Tutorial]]
'''Code-Beispiele'''
* [[Hallo Welt für AVR (LED blinken)]] - ein erstes Beispiel für avr-gcc
*[[:Kategorie:Quellcode_C|C-Codebeispiele]]
* [[Fallstricke bei der C-Programmierung]]

'''Details'''
* [[Inline-Assembler in avr-gcc|Inline-Assembler]]
* [[avr-gcc/Interna|Interna von avr-gcc]]

'''Installation (Linux)'''
* [[Linuxdistribution_Avr-live-cd]]
* [[avr-gcc und avrdude installieren]]
'''Sonstiges'''
* [[WinAVR]]
* [[Speicherverbrauch bestimmen mit avr-gcc]]
* [[Compiler]]
* [[Dev-Cpp IDE]]
* [[AVR]]
----
* [[Sourcevergleich]]
* [[Codevergleich AVR-Compiler]]

=Weblinks=
==Dokumentation==
* [http://gcc.gnu.org/onlinedocs/ GCC online documentation (en)] Offline findest du die Doku für gcc, cpp (Präprozessor) und avr-libc bei [[WinAVR]] in
:<pre><GCC_HOME>/doc/gcc/</pre>
: bzw.
:<pre><GCC_HOME>/doc/avr-libc/</pre>
:Online finden sich die Dokumente in
* [http://gcc.gnu.org/onlinedocs/gcc.pdf gcc.pdf (1900 kByte)] - Dokumentation des C/C++/Java-Compilers GCC (en)
* [http://gcc.gnu.org/onlinedocs/cpp.pdf cpp.pdf (470 kByte)] - Dokumentation des C-Präprozessors (en)
* [http://www.nongnu.org/avr-libc/user-manual/modules.html http://www.nongnu.org/avr-libc/user-manual] - Dokumentation zur avr-libc.

== Downloads==
* [http://sourceforge.net/projects/winavr/ WinAVR-Projekt bei sourceforge.net (en)]
* [http://cdk4avr.sourceforge.net/ avr-gcc und toolchain als Linux-Paket bei sourceforge.net (en)]
* [[Linuxdistribution_Avr-live-cd]]
== Tipps, Installation ==
*[http://www.nongnu.org/avr-libc/user-manual/install_tools.html ''"Installing the GNU Tool Chain"''] Hilfe zum Build und Installation von GCC, binutils, etc unter Linux
* Im GCC-Handbuch, siehe [[#Dokumentation|Dokumentation]].
* [http://www.linuxfocus.org/Deutsch/November2004/article352.shtml www.linuxfocus.org (Artikel)] - Tipps zu Build und Installation von avr-gcc, binutils und avr-libc unter Linux
* [http://users.rcn.com/rneswold/avr/ Rich Neswold: ''A GNU Development Environment for the AVR Microcontroller'']
* [http://www.mikrocontroller.net/topic/24166 www.mikrocontroller.net (Foren-Beitrag)] - Installation von GCC und Toolchain unter Mac OS X
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=125603#125603 www.roboternetz.de (Foren-Beitrag)] ''avrgcc + avrdude installieren''

== Sonstiges ==
* [http://gcc.gnu.org/ Offizielle Homepage von GCC (en)]
* [http://de.wikipedia.org/wiki/GNU_Compiler_Collection GCC in der deutschen Wikipedia]
* [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial avr-gcc-Tutorial auf mikrocontroller.net]
* [http://www.avrfreaks.net/AVRGCC/ avr-gcc bei avrfreaks.net (en)]
* [http://savannah.nongnu.org/projects/avr-libc/ Nützliche GCC Runtime-Libary]

=Autor=

--[[Benutzer:SprinterSB|SprinterSB]] 11:27, 7. Dez 2005 (CET)

[[Kategorie:Grundlagen]]
[[Kategorie:Microcontroller]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]

Avr-gcc

2007-03-20T10:05:57Z

Inrfb2: /* Zugiff auf Bytes und Worte */

'''avr-gcc''' ist ein freier C-[[Compiler]], mit dem man C-Programme zu ausführbaren Programmen übersetzen kann, die auf [[Microcontroller]]n der [[AVR]]-Familie lauffähig sind.
An Sprachen versteht avr-gcc sowohl C als auch [[#C%2b%2b|C++]].
Neben Standard-C bzw. ANSI-C versteht avr-gcc auch GNU-C, das etwas mehr Möglichkeiten und kleinere Spracherweiterungen bietet.

avr-gcc kann auch dazu verwendet werden, um C/C++ Programme nach Assembler zu übersetzen oder um Bibliotheken zu erstellen, die später in unterschiedlichen Projekten verwendet werden können.

Wie bei allen aus der UNIX-Welt kommenden Programmen ist das Kommando-Interface von avr-gcc die Shell bzw. die Kommandozeile, über die Optionen, Parameter, Einstellungen und die Namen der zu übersetzenden Dateien angegeben werden.

=How to Read=

Dieser Artikel bespricht avr-gcc Version 3.x. Er ist kein C-Tutorial und kein AVR-Handbuch – das würde den Umfang des Artikels bei weitem sprengen.

Der Artikel ist ein Handbuch zu avr-gcc. Er bespricht zum Beispiel, wie man avr-gcc anwendet und Besonderheiten von avr-gcc-C,
die nicht zum Sprachumfang von C gehören.
Dazu zählen die Definition von [[#Interrupts|Interrupt]] Service Routinen ([[ISR|ISRs]])
oder wie man Daten ins [[EEPROM]] legt.

Es wird also besprochen, ''wie'' eine ISR zu definieren ist, aber nicht,
''warum'' das gegebenenfalls notwendig oder nicht notwendig ist.
''Warum'' etwas gemacht wird, ist abhängig von der gestellten Aufgabe,
etwa ''"Initialisiere den [[UART]] zur Benutzung mit 9600 Baud"''.
Dafür enthält dieser Artikel zusammen mit dem AVR-Handbuch das Rüstzeug,
bietet aber keine Lösungen für konkrete Aufgaben.

Neben diesem Artikel gibt es den Unterartikel [[avr-gcc/Interna|Interna von avr-gcc]] wo Dinge wie die Registerverwendung, Attribute, Builtins und Sections von avr-gcc dargestellt werden. Zudem findet sich dort ein Überblick über die Arbeitsweise von gcc mit den Schritten
* Precompilieren
* Compilieren
* Assemblieren
* Linken
Ein weiterer Unterartikel widmet sich dem Thema [[Inline-Assembler in avr-gcc]].

In den [[:Kategorie:Quellcode C|C-Codebeispielen]]
befindet sich das ausführlichere Beispiel "[[Hallo Welt für AVR (LED blinken)]]",
das nur eine [[Diode#Lumineszenzdiode|LED]] blinkt und zeigt,
wie ein kleines Projekt mit avr-gcc compiliert werden kann.

Es gibt ein [[C-Tutorial]], das jedoch noch unvollständig und teilweise feherhaft ist (Stand 02/2006). Darüber hinaus gibt es ein [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial C-Tutorial bei www.mikrocontroller.net].

=Benutzer-Schnittstelle=

Die Benutzer-Schnittstelle von avr-gcc ist – wie für alle Programme, die aus der UNIX-Welt kommen – die Kommandozeile einer Shell, Console bzw. Eingabeaufforderung.

Im einfachsten Fall sieht ein Aufruf von avr-gcc also so aus:
> avr-gcc
Dabei das '<tt>></tt>' nicht mittippen, und ein ENTER am Ende der Zeile drücken.
Die Antwort bei korrekter Installation ist dann
avr-gcc: no input files
Was bedeutet: das Programm avr-gcc wurde vom Betriebssystem gefunden und konnte/durfte gestartet werden. Dann gibt avr-gcc eine Fehlermeldung aus und beendet die Ausführung, weil er keine Eingabedatei(en) bekommen hat was ja auch stimmt. Soweit ist also alles in Butter.

Um eine C-Datei <tt>foo.c</tt> mir avr-gcc optimiert zu einem lauffähigen elf-Programm <tt>foo.elf</tt> für einen [[ATmega32]] zu compileren, würde man angeben
> avr-gcc -O2 -mmcu=atmega32 foo.c -o foo.elf
Hat man seine Quellen auf zwei oder mehre Dateien verteilt, geht es analog:
> avr-gcc -O2 -mmcu=atmega32 foo.c foo2.c -o foo.elf

Will man nur eine Objekt-Datei erstellen (nur compilieren, nicht linken), dann geht das wie folgt. Das kann günstig sein bei grösseren Projekten, wenn man das Projekt neu erzeugen will, aber nur in einer Quelldatei was geändert hat. Oder wenn das Objekt in einer Bibliothek landen soll.
> avr-gcc -O2 -c -mmcu=atmega32 foo.c -o foo.o

Die ausführbare Gesamtdatei <tt>foo_all.elf</tt> erhält man dann, indem alle Objekte zusammenlinkt:
> avr-gcc -mmcu=atmega32 foo.o foo2.o foo3.o -o foo_all.elf

Um die ausführbare Datei in das oft verwendete Intex-HEX-Format umzuwandeln (einmal fürs Programm, einmal für ein Abbild des [[EEPROM]]s) gibt man an:
> avr-objcopy -O ihex -j .text -j .data foo_all.elf foo_all.hex
> avr-objcopy -O ihex -j .eeprom --change-section-lma .eeprom=0 foo_all.elf foo_all_eeprom.hex

----

[[GCC]] war immer Kommandozeilen-orientiert und wird es auch immer bleiben, denn das hat gute Gründe:
* ein Compiler ist ein Compiler ist ein Compiler (und keine grafische Bedienschnittstelle)
* die Plattformabhängigkeit wird auf ein Minimum reduziert
* es gibt die Möglichkeit, avr-gcc per Skript oder [[make]] zu starten
* avr-gcc kann durchaus in eine Umgebung integriert werden: in einen Editor oder in eine GUI wie neuere Versionen von AVR-Studio erfolgreich beweisen, etc. Der avr-gcc-Aufruf kann sogar von einem Server-Socket oder einer Web-Application heraus erfolgen, welche ein C-Programm empfängt, es von avr-gcc übersetzen lässt, und das Resultat zurückschickt oder sonst was damit anstellt.
* Lizenzgründe: eine Umgebung, die avr-gcc integriert, kann durchaus proprietär oder nicht quelloffen sein und muss nicht der [[Freie Software|GPL]] unterliegen. Wieder ist AVR-Studio ein Beispiel.

= Unterstützte AVR-Derivate=
;Classic AVR:: [[AT90S1200]], [[AT90S2313]], [[AT90S8515]], [[AT90S8535]], [[AT90S4433]], [[AT90S4414]], [[AT90S4434]], [[AT90S2323]], [[AT90S2333]], [[AT90S2343]],

;tinyAVR:: [[ATtiny10]], [[ATtiny11]], [[ATtiny12]], [[ATtiny15]], [[ATtiny28]], [[ATtiny22]], [[ATtiny26]], [[AT90C8534]], [[AT86rf401]], [[ATtiny13]], [[ATtiny2313]], [[ATtiny261]], [[ATtiny461]], [[ATtiny861]], [[ATtiny24]], [[ATtiny44]], [[ATtiny84]], [[ATtiny25]], [[ATtiny45]], [[ATtiny85]]

;megaAVR:: [[ATmega603]], [[ATmega103]], [[AT76C711]], [[ATmega48]], [[ATmega8]], [[ATmega83]], [[ATmega85]], [[ATmega88]], [[ATmega8515]], [[ATmega8535]], [[ATmega16]], [[ATmega161]], [[ATmega162]], [[ATmega163]], [[ATmega164p]], [[ATmega165]], [[ATmega165P]], [[ATmega168]], [[ATmega32]], [[ATmega323]], [[ATmega324P]], [[ATmega325]], [[ATmega3250]], [[ATmega64]], [[ATmega640]], [[ATmega644]], [[ATmega644P]], [[ATmega128]], [[ATmega1280]], [[ATmega1281]], [[ATmega645]], [[ATmega6450]], [[AT94K]]

; [[LCD]] AVR:: [[ATmega169]], [[ATmega169P]], [[ATmega329]], [[ATmega3290]], [[ATmega649]], [[ATmega6490]],
; Lightning AVR:: [[AT90PWM2]], [[AT90PWM3]]
; [[CAN]] AVR:: [[AT90CAN32]], [[AT90CAN64]], [[AT90CAN128]]
; Smart Battery:: [[ATmega406]]
; [[USB]] AVR:: [[AT43USB320]], [[AT43USB355]], [[AT90USB646]], [[AT90USB647]], [[AT90USB1286]], [[AT90USB1287]]
;

Diese Liste kann man avr-gcc anzeigen lassen mit
> avr-gcc --target-help

=Kommandozeilen-Optionen=
Die Codegenerierung bei avr-gcc wird über Kommandozeilen-Optionen gesteuert. Diese legen fest, für welchen Controller Code zu erzeugen ist, wie stark optimiert wird, ob Debug-Informationen erzeugt werden, etc. Die Optionen teilen sich in zwei Gruppen: Optionen, die für alle GCC-Ports verfürgbar sind und maschinenspezifische Optionen, die nur für AVR verfügbar sind.

Aus der Masse an GCC-Optionen kann hier nur ein kleiner Auszug der wichtigsten und am häufigsten verwendeten Optionen vorgestellt werden. Eine Auflistung aller GCC-Optionen mit Kurzbeschreibung umfasst knapp 1000 Zeilen ohne undokumentierte Optionen, versteht sich.

==Allgemeine Optionen für GCC==
; <tt>--help</tt>: Anzeige der wichtigsten Optionen
; <tt>--help -v</tt>: Überschüttet einen mit Optionen
; <tt>--target-help</tt>: Anzeige der wichtigsten maschinenspezifischen Optionen und der unterstützten AVR-Derivate
; <tt>-O0</tt>: keine Optimierung
; <tt>-O1</tt>: Optimierung
; <tt>-Os</tt>: optimiert für Code-Größe
; <tt>-O2</tt>: stärkere Optimierung für bessere Laufzeit
; <tt>-g</tt>: erzeugt Debug-Informationen
; <tt>-c</tt>: (pre)compilert und assembliert nur bis zum Objekt (<tt>*.o</tt>), kein Link-Lauf
; <tt>-S</tt>: (pre)compilert nur und erzeugt Assembler-Ausgabe (*.s)
; <tt>-E</tt>: nur Precompilat (<tt>*.i</tt>) erzeugen, kein Compilieren, kein Assemblieren, kein Linken
; <tt>-o <filename></tt>: legt den Name der Ausgabedatei fest
; <tt>-v</tt>: zeigt Versionsinformationen an und ist geschwätzig (verbose): Anzeige der aufgerufenen tools
; <tt>-I<path></tt>: Angabe eines weiteren Include-Pfads, in dem Dateien mit <tt>#include <...></tt> gesucht werden
; <tt>-E -dM <filename></tt>: Anzeige aller Defines
; <tt>-MM</tt>: Für die angegebenen Eingabe-Dateien wird eine Ausgabe erzeugt, die als [[make|Makefile]]-Fragment dienen kann und die Anhängigkeiten (dependencies) der Objekte von den Quellen/Headern beschreibt.
; <tt>-D<name></tt>: Definiert Makro <tt><name></tt>
; <tt>-D<name>=<wert></tt>: Definiert Makro <tt><name></tt> zu <tt><wert></tt>
; <tt>-U<name></tt>: Undefiniert Makro <tt><name></tt>
; <tt>-save-temps</tt>: Temporäre Dateien (<tt>*.i</tt>, <tt>*.s</tt>) werden nicht gelöscht. Teilweise fehlerhaft zusammen mit <tt>-c</tt>
; <tt>-Wa,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Assembler (<tt>avr-as</tt>)
:;<tt>-Wa,-a=<filename></tt>: Assembler erzeugt ein Listing mit Name <tt><filename></tt>
; <tt>-Wp,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Preprozessor
; <tt>-Wl,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Linker (<tt>avr-ld</tt>)
:;<tt>-Wl,-Map=<filename></tt>: Linker erzeugt ein Map-File mit Name <tt><filename></tt>
:;<tt>-Wl,--oformat=<format></tt>: Linker erzeugt Ausgabe im Format <tt><format></tt>, z.b. <tt>ihex</tt> für Intel-HEX-File
:;<tt>-Wl,--section-start=<section>=<address></tt>: Linker legt die [[avr-gcc/Interna#Sections|Section]] <tt><section></tt> ab Adresse <tt><address></tt>, z.B: <tt>.eeprom=0x810001</tt>
; <tt>-Wall</tt>: gibt mehr Warnungen, aber immer noch nicht alle
; <tt>-pedantic</tt>: geht besonders pedantisch mit Code um
; <tt>-std=c89 -ansi</tt>: bricht mit einer Fehlermeldung ab, wenn kein ANSI-C (ISO C89) verwendet wurde
; <tt>-std=c99</tt>: bricht mit einer Fehlermeldung ab, wenn kein ISO C99 verwendet wurde
; <tt>-ffreestanding</tt>: Das erzeugte Programm läuft nicht in einer Umgebung wie einer Shell. Der Prototyp von <tt>main</tt> ist
:<pre>void main (void);</pre>

==Maschinenspezifische Optionen für avr-gcc==
Maschinenabhängige Optionen beginnen immer mit '''-m'''
;-mmcu=xxx: Festlegen des Targets (Zielsystem/Controller), für das Code generiert werden soll. Je nach Target muss avr-gcc unterschiedliche Instruktionen verwenden und andere Startup-Dateien (<tt>crtxxx.o</tt>) einbinden. avr-gcc setzt spezielle Defines, um auch in der Quelle zwischen den Targets unterscheiden zu können, falls das notwendig sein sollte:
:{| border="0" cellpadding="0" cellspacing="0"
|
<pre>
#ifdef __AVR_AT90S2313__
/* Code fuer AT90S2313 */
#elif defined (__AVR_ATmega8__) || defined (__AVR_ATmega32__)
/* Code fuer Mega8 und Mega32 */
#else
#error Das ist noch nicht implementiert für diesen Controller!
#endif
</pre>
|}

Zwar gibt es für alle AVR-Derivate die <tt>avr/io.h</tt>, aber die AVR-Familien unterscheiden sich in ihrer Hardware; z.B. darin, wie I/O-Register heissen oder wie Hardware zu initialisieren ist. Diese Abhängigkeit kann man in unterschiedlichen Codestücken aufteilen und wie oben gezeigt bedingt übersetzen. Dadurch hat man Funktionalitäten wie <tt>uart_init</tt> auf unterschiedlichen Controllern und wahrt den Überblick, weil nicht für jede Controller-Familie eine extra Datei notwendig ist.
{|
|- valign="top"
|
:{| {{Blauetabelle}}
|+ '''AVR classic, <= 8 kByte'''
|- {{Hintergrund1}}
!|mcu || Builtin define
|-
|avr2 ||<tt>__AVR_ARCH__=2</tt>
|-
|[[AT90S2313|at90s2313]] ||<tt>__AVR_AT90S2313__</tt>
|-
|at90s2323 ||<tt>__AVR_AT90S2323__</tt>
|-
|at90s2333 ||<tt>__AVR_AT90S2333__</tt>
|-
|at90s2343 ||<tt>__AVR_AT90S2343__</tt>
|-
|attiny22 ||<tt>__AVR_ATtiny22__</tt>
|-
|attiny26 ||<tt>__AVR_ATtiny26__</tt>
|-
|at90s4414 ||<tt>__AVR_AT90S4414__</tt>
|-
|at90s4433 ||<tt>__AVR_AT90S4433__</tt>
|-
|at90s4434 ||<tt>__AVR_AT90S4434__</tt>
|-
|at90s8515 ||<tt>__AVR_AT90S8515__</tt>
|-
|at90c8534 ||<tt>__AVR_AT90C8534__</tt>
|-
|at90s8535 ||<tt>__AVR_AT90S8535__</tt>
|-
|at86rf401 ||<tt>__AVR_AT86RF401__</tt>
|}
| 
:{| {{Blauetabelle}}
|+ '''AVR classic, > 8 kByte'''
|- bgcolor="#ccccff"
! |mcu ||Builtin define
|-
|avr3 ||<tt>__AVR_ARCH__=3</tt>
|-
|atmega103 ||<tt>__AVR_ATmega103__</tt>
|-
|atmega603 ||<tt>__AVR_ATmega603__</tt>
|-
|at43usb320 ||<tt>__AVR_AT43USB320__</tt>
|-
|at43usb355 ||<tt>__AVR_AT43USB355__</tt>
|-
|at76c711 ||<tt>__AVR_AT76C711__</tt>
|}
|}

----

{|
|- valign="top"
|
:{| {{Blauetabelle}}
|+ '''AVR enhanced, <= 8 kByte'''
|- bgcolor="#ccccff"
!|mcu || Builtin define
|-
|avr4 ||<tt>__AVR_ARCH__=4</tt>
|-
|[[Atmel Controller Mega8|atmega8]] ||<tt>__AVR_ATmega8__</tt>
|-
|atmega8515 ||<tt>__AVR_ATmega8515__</tt>
|-
|atmega8535 ||<tt>__AVR_ATmega8535__</tt>
|}
|
:{| {{Blauetabelle}}
|+ '''AVR enhanced, > 8 kByte'''
|- bgcolor="#ccccff"
!|mcu ||Builtin define
|-
|avr5 ||<tt>__AVR_ARCH__=5</tt>
|-
|[[Atmel Controller Mega16 und Mega32|atmega16]] ||<tt>__AVR_ATmega16__</tt>
|-
|atmega161 ||<tt>__AVR_ATmega161__</tt>
|-
|atmega162 ||<tt>__AVR_ATmega162__</tt>
|-
|atmega163 ||<tt>__AVR_ATmega163__</tt>
|-
|atmega169 ||<tt>__AVR_ATmega169__</tt>
|-
|[[Atmel Controller Mega16 und Mega32|atmega32]] ||<tt>__AVR_ATmega32__</tt>
|-
|atmega323 ||<tt>__AVR_ATmega323__</tt>
|-
|[[ATMega64|atmega64]] ||<tt>__AVR_ATmega64__</tt>
|-
|[[Atmel Controller Mega128|atmega128]] ||<tt>__AVR_ATmega128__</tt>
|-
|at94k ||<tt>__AVR_AT94K__</tt>
|}
|}

----

:{| {{Blauetabelle}}
|+ '''AVR, nur Assembler'''
|- bgcolor="#ccccff"
! |mcu ||Builtin define
|-
|avr1 ||<tt>__AVR_ARCH__=1</tt>
|-
|at90s1200 ||<tt>__AVR_AT90S1200__</tt>
|-
|attiny11 ||<tt>__AVR_ATtiny11__</tt>
|-
|attiny12 ||<tt>__AVR_ATtiny12__</tt>
|-
|attiny15 ||<tt>__AVR_ATtiny15__</tt>
|-
|attiny28 ||<tt>__AVR_ATtiny28__</tt>
|}

----

; -minit-stack=xxx: Festlegen der Stack-Adresse
; -mint8: Datentyp <tt>int</tt> ist nur 8 Bit breit, anstatt 16 Bit. Datentypen mit 32 Bit wie <tt>long</tt> sind nicht verfügbar
; -mno-interrupts: Ändert den Stackpointer ohne Interrupts zu deaktivieren
; -mcall-prologues: Funktions-Prolog und -Epilog werden als Unterroutinen umgesetzt, um die Codegröße zu verkleinern
; -mtiny-stack: Nur die unteren 8 Bit des Stackpointers werden verändert
; -mno-tablejump: Für ein <tt>switch</tt>-Statement werden keine Sprungtabellen angelegt
; -mshort-calls: Verwendet <tt>rjmp</tt>/<tt>rcall</tt> (begrenzte Sprungweite) auf Devices mit mehr als 8 kByte Flash
; -msize: Ausgabe der Instruktonslängen im asm-File
; -mdeb: (undokumentiert) Ausgabe von Debug-Informationen für GCC-Entwickler
; -morder1: (undokumentiert) andere Register-Allokierung
; -morder2: (undokumentiert) andere Register-Allokierung

=C++=

:''"C++ is a complex language and an evolving one, and its standard definition (the ISO C++ standard) was only recently completed. As a result, your C++ compiler may occasionally surprise you, even when its behavior is correct."''

Zudem sollte der Einsatz von C++ aus Effizienzgründen sehr kritisch betrachtet werden:
:''"When programming C++ in space- and runtime-sensitive environments like microcontrollers, extra care should be taken to avoid unwanted side effects of the C++ calling conventions like implied copy constructors that could be called upon function invocation etc. These things could easily add up into a considerable amount of time and program memory wasted. Thus, casual inspection of the generated assembler code (using the <tt>-S</tt> compiler option) seems to be warranted."''

Weiterhin unterliegt der Einsatz von C++ je nach Compiler/Lib-Version bestimmten Einschränkungen:
*Einer kompletten C++ Implementierung fehlt die Unterstützung durch die <tt>libstdc++</tt>, dadurch fehlen Standardfunktionen, -Klassen und -Templates
* Die Operatoren <tt>new</tt> und <tt>delete</tt> sind nicht implementiert, ihre Verwendung führt zu unauflösbaren externen Referenzen (Linker-Fehler)
*Nicht alle Header sind C++-sicher und müssen in <tt>extern "C" {...}</tt> eingeschlossen werden.
*Exceptions werden nicht unterstützt und müssen via <tt>-fno-exceptions</tt> abgeschaltet werden, oder der Linker beschwert sich über eine unauflösbare externe Referenz zu <tt>__gxx_personality_sj0</tt>.

Als Treiber verwendet man wie immer avr-gcc. Standard-Endungen für C++ sind <tt>.c++</tt> und <tt>.cpp</tt>. Bei anderen Endungen teilt man mit <tt>-x c++</tt> mit, daß es sich um C++ Dateien handelt, oder ruft <tt>avr-c++</tt> direkt auf.

Interrupt-Service-Routinen (ISRs) sind C-Funktionen und werden definiert wie gehabt. Siehe auch [[#Interrupts|Interrupts]].
#include <avr/io.h>
#include <avr/interrupt.h>

#if defined (__cplusplus)
extern "C" {
#endif {{comment|__cplusplus}}

SIGNAL (SIG_NAME)
{
{{comment|machwas}}
}

INTERRUPT (SIG_NAME)
{
{{comment|mach was}}
}

#if defined (__cplusplus)
}
#endif {{comment|__cplusplus}}
<tt>__cplusplus</tt> ist ein Standard [[avr-gcc/Interna#Builtin Defines|GCC-Builtin-Define]].

Globale Konstruktoren werden in [[avr-gcc/Interna#Sections|Section]] <tt>.init6</tt> ausgeführt, die Destruktoren in <tt>.fini6</tt>.

=Code-Beispiele=
Dieser Abschnitt enthält Code-Schnippsel für avr-gcc. Es werden Besonderheiten besprochen, die für avr-gcc zu beachten sind.

Dieser Abschnitt ist ''kein'' [[C-Tutorial|Tutorial zur C-Programmierung]] und ''keine'' Einführung in die Programmiersprache C im allgemeinen. Dafür sei auf einschlägige Tutorials/Bücher verwiesen.

==Zugriff auf Special Function Registers (SFRs)==

===Zugiff auf Bytes und Worte===
For dem Zugriff auf die SFRs gibt es Defines über den Include
#include <avr/io.h>
Abhängig vom eingestellten Controller werden denn Defines eingebunden, über die auf SFRs wie auf normale Variablen zugegriffen werden kann. Die Namen der Defines sind i.d.R. die gleichen wie im AVR-Manual, also z.b. <tt>SREG</tt> für das Prozessorstatus-Register SREG:
#include <avr/io.h>

...
{{ccomment|SREG lesen}}
uint8_t sreg = SREG;
...
{{ccomment|SREG schreiben}}
SREG = sreg;

Für einen Überblick über die eingebundenen Defines und kann ein Blick in den Controller-spezifischen Header hilfreich sein. Dieser befindet sich in
:<tt> <GCC_HOME>/avr/include/avr/io****.h</tt>
z.B. <tt>iom32.h</tt> für einen [[ATmega32]].

Dieser Zugriff geht auch für 16-Bit Register wie <tt>TCNT1</tt>, für die eine bestimmte Reihenfolge für den Zugriff auf Low- und High-Teil eingehalten werden muss: avr-gcc generiert die Zugriffe in der richtigen Reihenfolge.
uint16_t tcnt1 = TCNT1;

{{FarbigerRahmen|
Zu beachten ist, daß dieser Zugriff nicht atomar erfolgt. Das Lesen/Schreiben mehrbytiger Werte muss vom Compiler in mehrere Byte-Zugriffe zerlegt werden. Zwischen diesen Zugriffen kann ein [[Interrupt]] auftreten, wenn Interrupts aktiviert sind. Je nach Programm und welche Aufgaben eine [[ISR]] erledigt, kann dies zu Fehlfunktion führen. In dem Fall müssen diese Code-Stücke atomar gemacht werden, damit sie nicht durch einen [[IRQ]] unterbrochen werden können!
}}

===Zugriff auf einzelne Bits===
Zugriff auf Bits geht wie gewohnt mit den Bitoperationen
<tt>&</tt> (and),
<tt>|</tt> (or),
<tt>^</tt> (xor) und
<tt>~</tt> (not)

Wieder gibt es Defines in den AVR-Headern, mit denen man Masken für den Zugriff erhalten kann, etwa:
<pre>
/* GIMSK / GICR */
#define INT1 7
#define INT0 6
#define IVSEL 1
#define IVCE 0
</pre>

Masken ergeben sich durch Schieben von <tt>1</tt> an die richtige Position:
<pre>
// Ports B_0 und B_1 als Ausgang
DDRB |= (1<<PB0) | (1<<PB1);
</pre>
erzeugt
<pre>
87 b3 in r24, 0x17
83 60 ori r24, 0x03
87 bb out 0x17, r24
</pre>

Etwas anders sieht der Code aus, wenn die Bits einzeln gesetzt werden und das Register im bitadressierbaren Bereich liegt (SRAM <tt>0x20</tt> bis <tt>0x3f</tt> resp. I/O <tt>0x0</tt> bis <tt>0x1f</tt>):
<pre>
// Ports B_0 und B_1 als Ausgang
DDRB |= (1<<PB0);
DDRB |= (1<<PB1);
</pre>
erzeugt
<pre>
b8 9a sbi 0x17, 0
b9 9a sbi 0x17, 1
</pre>

Um Bits zu löschen, erzeugt man eine Maske, die an der betreffenden Stelle eine  0 hat:
<pre>
// Ports B_2 als Eingang
DDRB &= ~(1<<PB2);
</pre>

{{FarbigerRahmen|
Auch hier ist zu beachten, daß es Probleme geben kann, wenn nicht atomarer Code erzeugt wird, weil der AVR-Befehlssatz nicht mehr hergibt:
<pre>
// toggle PORT B_0: wechseln 0 <--> 1
PORTB ^= (1<<PB0);
</pre>
ergibt
<pre>
88 b3 in r24, 0x18
; Wenn hier ein Interrupt auftritt, in dessen ISR PORTB verändert wird,
; dann wird die Änderung durch die letzte Instruktion wieder überschrieben!
91 e0 ldi r25, 0x01
; dito
89 27 eor r24, r25
; dito
88 bb out 0x18, r24
</pre>
}} 

Auch das Lesen einzelner Port-Pins geht über das Maskieren von SFRs:
<pre>
DDRB &= ~(1 << PB2); // PortB.2 als INPUT

if (PINB & (1 << PB2))
// PortB.2 ist HIGH
else
// PortB.2 ist LOW

if (!(PINB & (1 << PB2)))
// PortB.2 ist LOW
else
// PortB.2 ist HIGH
</pre>

==Interrupts==

Um zu kennzeichnen, daß es sich bei einer Funktion um eine Interrupt Sevice Routine (ISR) handelt, gibt es spezielle Attribute. Diese brauchen nicht explizit hingeschrieben zu werden, ebensowenig wie die genaue Nummer des Interrupt Requests (IRQ). Dafür gibt es Includes und die folgenden Makros.

Bitte beachte auch die Hinweise zu den [[#Inkompatibilität|Inkompatibilität]]en von avr-gcc!
#include <avr/io.h>
#include <avr/interrupt.h>

{{ccomment|Eine nichtunterbrachbare Interrupt-Service-Routine}}
SIGNAL (SIG_OUTPUT_COMPARE1A)
{
{{ccomment|ISR-Code}}
}

{{ccomment|Eine unterbrachbare Interrupt-Service-Routine}}
INTERRUPT (SIG_OUTPUT_COMPARE1B)
{
{{ccomment|ISR-Code}}
}

Dadurch wird die Funktion mit dem richtigen Prolog/Epilog erzeugt, und es wird ein Eintrag in die Interrupt-Vektortabelle gemacht bei obigem Beispiel also zwei Einträge.

{{FarbigerRahmen|
Die Schreibweise des Signal-Names muss genau die sein wie im Header, das schliesst auch Leerzeichen ein! Nicht alle GCC-Versionen bringen Fehler/Warnung, wenn die Schreibweise nicht stimmt.
SIGNAL (SIG_OUTPUT_COMPARE1A ) // !!! Macht NICHT das, was man will (Blank am Ende)!!!
}}

;<tt>SIGNAL</tt>: Mit Ausführung einer ISR deaktiviert die AVR-Hardware die Interrupts, so daß die ISR nicht durch andere Interrupt-Anforderungen unterbrochen wird. Beim Verlassen der ISR werden Interrupts wieder automatisch aktiviert. Tritt während der ISR ein IRQ auf, wird diese erst nach Beenden des ISR-Codes ausgeführt. Der Interrupt geht also nicht verloren. Zwischen zwei ISRs wird zusätzlich mindestens ein Befehl des normalen Programm-Codes abgearbeitet.
;<tt>INTERRUPT</tt>: Früh im ISR-Prolog werden mit <tt>sei</tt> die von der AVR-Hardware temporär deaktivierten Interrupts reaktiviert. Dadurch kann die ISR von einer IRQ unterbrochen werden. Das bietet die Möglichkeit, so etwas wie Interrupt-Priorisierung nachzubilden, was AVRs selbst nicht können. Weiterhin kann man schneller auf bestimmte Ereignisse reagieren. Tritt während der ISR ein anderer IRQ auf, der schnell bedient werden muss, kann sofort der dringende ISR-Code ausgeführt werden. Ansonsten (Verwendung von <tt>SIGNAL</tt>) würde der Code erst ausgeführt werden, nachdem die aktuelle ISR beendet ist.

{{FarbigerRahmen|Dauert die ISR zu lange und wird sie nochmals von ihrem eigenen IRQ unterbrochen, stürzt man ab.}}

Nachschlagen kann man den Namen in
:<tt><GCC_HOME>/avr/include/avr/ioxxxx.h</tt>

===Interrupts aktivieren===

Damit eine ISR überhaupt zur Ausführung kommt, müssen drei Bedingungen erfüllt sein
* Interrupts müssen global aktiviert sein
* Der entsprechen IRQ muss aktiviert worden sein
* Das zum IRQ gehörende Ereignis muss eintreten
#include <avr/io.h>
#include <avr/interrupt.h>

...
{{ccomment|enable OutputCompareA Interrupt für Timer1}}
TIMSK |= (1 << OCIE1A);

{{ccomment|disable OutputCompareA Interrupt für Timer1}}
TIMSK &= ~(1 << OCIE1A);

{{ccomment|Interrupts aktivieren}}
sei();

{{ccomment|Interrupts abschalten}}
cli();
Sperrt man eine Code-Sequenz durch Einschachteln in ein <tt>cli</tt>/<tt>sei</tt> Paar (man macht das Codestück "atomar", also ununterbrechbar), gehen währenddessen keine Interrupt-Anforderungen verloren. Die entsprechenden IRQ-Flags bleiben gesetzt, und nach dem <tt>sei</tt> werden die IRQs in der Reihenfolge ihrer Prioritäten abgearbeitet. Ausnahme ist, wenn in einem atomaren Block der selbe IRQ mehrfach auftritt. Der ISR-Code wird dann trotzdem nur einmal ausgeführt.

===default Interrupt===

Für nicht implementierte Interrupts macht avr-gcc in die Vektortabelle einen Eintrag,
der zu <tt>__bad_interrupt</tt> (definiert im Startup-Code <tt>crt*.o</tt>) springt
und von dort aus weiter zu Adresse 0.
Dadurch läuft der AVR wieder von neuem los, wenn ein Interrupt auftritt,
zu dem man keine ISR definiert hat
 allerdings ohne die Hardware zurückzusetzen wie bei einem echten Reset.

Möchte man diesen Fall abfangen, dann geht das über eine globale Funktion
namens <tt>__vector_default</tt>:
<pre>
#include <avr/interrupt.h>

SIGNAL (__vector_default)
...
</pre>
Damit wird von <tt>__bad_interrupt</tt> aus nicht nach Adresse 0 gesprungen,
sondern weiter zu <tt>__vector_default</tt>, welches durch <tt>SIGNAL</tt> oder
<tt>INTERRUPT</tt> den üblichen ISR-Prolog/Epilog bekommt.

So kann man z.B. eine Meldung ausgeben, eine Warnlampe blinken, in einer Endlosschleife landen, oder über den [[Watchdog]] einen richtigen Hardware-Reset auslösen, siehe auch Abschnitt "[[#Reset auslösen|Reset auslösen]]".

===ISR mit eigenem Prolog/Epilog===

Wenn man in einer ISR komplett eigenes Zeug machen will,
dann definiert man eine nackte Funktion.
Mit <tt>naked</tt> befreit man die Routine vom Standard-Prolog/Epilog.
{{FarbigerRahmen|
Dabei ist darauf zu achten, daß die ISR mit <tt>reti</tt> (return from interrupt)
zurückkehrt und evtl. verwendete Register und den Status (<tt>SREG</tt>) sichert.
}}
#include <avr/io.h>

void __attribute__ ((naked))
SIG_OVERFLOW0 (void)
{
{{ccomment|Port B.6 = 0}}
{{ccomment|Diese Instruktion verändert nicht das SREG und kein anderes Register}}
{{ccomment|so daß der eigentliche Code nur 1 Befehl lang ist}}
__asm__ __volatile (
"cbi %0, %1" "\n\t"
"reti"
:
: "M" (_SFR_IO_ADDR (PORTB)), "i" (6)
);
}

Siehe auch [[Inline-Assembler in avr-gcc]].
Die ISR sieht dann so aus:
<pre>
__vector_9:
c6 98 cbi 0x18, 6
18 95 reti
</pre>

Wiederum kann man als Funktionsname <tt>__vector_default</tt> nehmen,
um nicht-implementierte IRQs abzufangen:
<pre>
void __attribute__ ((naked))
__vector_default (void)
...
</pre>

==SRAM, Flash, EEPROM: Datenablage am Beispiel Strings==
Die Programmiersprache C kennt selber keine Strings; das einzige, was C bekannt ist, ist der Datentyp <tt>char</tt>, der ein einzelnes Zeichen repräsentiert.
===Darstellung in C===
Ein String im Sinne von C ist ein Array von Charactern bzw. ein Zeiger auf den Anfang des Arrays. Die einzelnen Zeichen folgen im Speicher direkt aufeinander und werden in aufsteigenden Adressen gespeichert. Am String-Ende folgt als Abschluss der Character <tt>'\0'</tt>, um das Ende zu kennzeichnen. Dies ist besonders bei der Berechnung des Speicherplatzes für Strings zu berücksichtigen, denn für die 0 muss auch Platz reserviert werden.

===Bestimmen der Stringlänge===
<pre>
/* Bestimmt die Laenge des Strings ohne die abschliessende '\0' zu zaehlen */
unsigned int strlength (const char *str)
{
unsigned int len = 0;

while (*str++)
len++;

return len;
}
</pre>

Die Stringlänge kann auch mit der Standard-Funktion <tt>strlen</tt> bestimmt werden, deren Prototyp sich in <tt>string.h</tt> befindet:
<pre>
#include <string.h>
size_t strlen (const char*);
</pre>

===String im Flash belassen===
Oftmals werden Strings nur zu Ausgabezwecken verwendet und nicht verändert. Verwendet man Sequenzen der Gestalt
<pre>
char *str1 = "Hallo Welt!";
char str2[] = "Hallo Welt!";
</pre>
dann werden die Strings im SRAM abgelegt. Im Startup-Code werden die Strings vom Flash ins SRAM kopiert und belegen daher sowohl Platz im SRAM als auch im Flash. Wird ein String nicht verändert, braucht er nicht ins SRAM kopiert zu werden. Das spart Platz im knapp bemessenen SRAM. Allerdings muss anders auf den String zugegriffen werden, denn wegen der Harvard-Architektur des AVR-Kerns kann avr-gcc anhand der Adresse nicht unterscheiden, ob diese ins SRAM, ins Flash oder ins EEPROM zeigt.
<pre>
#include <avr/pgmspace.h>

const prog_char str3[] = "Hallo Welt!";

unsigned int strlen_P (const prog_char *str)
{
unsigned int len = 0;

while (1)
{
char c = (char) pgm_read_byte (str);
if ('\0' == c)
return len;
len++;
str++;
}
}

void foo()
{
unsigned int len;
len = strlen_P (str3);
len = strlen_P (PSTR("String im Flash"));
}
</pre>

===String ins EEPROM legen===
Dies geht nach dem gleichen Muster, nach dem Strings ins Flash gelegt werden. Der Zugriff wird vergleichsweise langsam, denn der EEPROM ist langsamer als SRAM bzw. Flash.
<pre>
#include <avr/eeprom.h>

const char str4[] __attribute__ ((section(".eeprom"))) = "Hallo Welt!";

unsigned int strlen_EE (const char *str)
{
unsigned int len = 0;

while (1)
{
char c = (char) eeprom_read_byte (str);
if ('\0' == c)
return len;
len++;
str++;
}
}
</pre>

==Reset auslösen==
Falls ein Reset per Software ausgelöst werden soll, dann geht das am besten über den [[Watchdog]].
Einfach nur an den RESET-Punkt an Adresse 0 zu springen mit
goto *((void**) 0);
initialisiert zwar den Controller von neuem, aber es macht keinen wirkliches RESET mit Zurücksetzen der Hardware und allen I/O-Registern.

Durch den Watchdog kann man ein 'richtiges' RESET-Signal erzeugen lassen, so daß die AVR-Hardware genau so initialisiert ist, wie nach einem externen RESET. So kann man z.B. via [[UART]] ein RESET-Kommando schicken. Allerdings lässt sich der Watchdog nur minimal auf 15ms einstellen:

#include <avr/wdt.h>
#include <avr/interrupt.h>
...
cli(); {{ccomment|Interrupts global abschalten}}
wdt_enable (WDTO_15MS); {{ccomment|Watchdog aufziehen auf 15ms}}
while (1); {{ccomment|warten, bis er zubeisst...}}

Welches Ereignis einen RESET ausgelöst hat, kann man im Register '''MCUCSR''' (''MCU Control and Status Register'') erfahren. Es gibt 4 mögliche RESET-Quellen:
* Power-On Reset
* External Reset
* Brown-Out Reset
* Watchdog Reset

Soll der Inhalt von Variablen einen Reset überleben – eine Variable also nicht initialisiert werden – dann geht das so:
#include <avr/io.h>

{{ccomment| status informiert z.B. darüber, ob wir selber den Watchdog ausgelöst haben }}
{{ccomment| oder nicht, oder andere Informationen }}
unsigned char status __attribute__ ((section (".noinit")));

void main (void)
{
{{ccomment|Wert von MCUSCR merken, möglichst früh im Programm }}
unsigned char mcucsr = MCUCSR;

{{ccomment|MCUCSR zurücksetzen }}
MCUCSR = 0;

{{ccomment|Watchdog-Reset }}
if (mcuscr & (1 << WDRF))
{
{{ccomment|status auswerten }}
}

{{ccomment|Power-On Reset: status auf definierten Wert setzen }}
if (mcuscr & (1 << PORF))
{
status = 0;
}

{{ccomment|status auswerten }}
...
}

=Includes=

Die mit
#include <...>
angegebenen Includes werden von avr-gcc in den
mit der Option '<tt>-I</tt>' anegegenen Pfaden gesucht.
Dem Compiler bekannt sind die Pfade
<GCC_HOME>/avr/include Standard (stdio.h, ...)
<GCC_HOME>/avr/include/avr AVR-spezifisch (avr/io.h, ...)
<GCC_HOME>/lib/gcc/avr/<GCC_VERSION>/include Standard, compilerabh. (limits.h, ...)

Gibt man z.B. an
#include <stdio.h>
dann wird automatisch in diesem Verzeichnis nach <tt>stdio.h</tt> gesucht.
In den Verzeichnissen stehen Standard-Includes, die benötigt werden, wenn man libc-Funktionen
oder mathematische Funktionen etc. verwendet.
AVR-spezifische Dinge stehen im Unterverzeichnis <tt>avr</tt>, etwa:
#include <avr/io.h>
{{FarbigerRahmen|
Als Pfad-Separator wird immer ein '''<tt>/</tt>''' verwendet, auch auf Windows-Betriebssystemen! Also kein '''<tt>\</tt>''' !
}}

==Standard==

ctype.h Zeichen-Umwandlungs-Makros und ctype Makros
errno.h Symbolische Namen für Fehlercodes
inttypes.h Definiert [u]intN_t wenn man genau N [un]signed Bits
braucht, ISO C99.
math.h Mathematische Funktionen: sin, cos, log, gamma, bessel, ...
setjmp.h libc unterstützt setjmp() und longjmp(), um direkt in eine
andere (nicht-lokale) Funktion zu springen.
stdio.h Standard I/O-Funktionen (printf, ...).
stdlib.h Deklariert grundlegende ISO C-Makros und -Funktionen
sowie einige AVR-spezifische Erweiterungen
string.h Stringoperationen auf NULL-terminierten Strings. (strlen, ...)
stdarg.h Funktionen mit variabler Argumenanzahl
limits.h Min- und Max-Werte von Skalaren (UCHAR_MAX, LONG_MIN, ...)

==AVR-spezifisch==

Die AVR-spezifischen Includes finden sich wie gesagt im Unterverzeichnis <tt>avr</tt>.
Die meisten dort befindlichen Header wird man nie direkt durch Angabe im C-File erhalten,
sondern durch Angabe von
#include <avr/io.h>
Dadurch werden z.B. genau die I/O-Header eingebunden, die zum AVR-Modell passen, also
*<tt>avr/iom8.h</tt> für [[ATmega8]],
*<tt>avr/iotn2313.h</tt> für [[ATtiny2313]],
*<tt>avr/io2313.h</tt> für [[AT90S2313]], etc.

Verantwortlich dafür ist der Schalter '<tt>-mmcu=xxx</tt>'.

Obwohl diese Header nicht explizit angegeben werden müssen,
kann ein Blick dorthin hilfreich sein, um die Namen von [[SFR|SFRs]]
oder Signals nachzuschlagen.
Diese Header werden im folgenden nicht alle einzeln aufgelistet.
Ihre Namen sind immer <tt>avr/io*.h</tt>.
* für ATmega: <tt>avr/iom*.h</tt>
* für ATtiny: <tt>avr/iotn*.h</tt>
<pre>
avr/boot.h Bootloader Support
avr/crc16.h [*] Prüfsumme CRC16
avr/delay.h [*] Verzögerungsschleifen für kurze, exakte Verzögerungen
avr/eeprom.h EEPROM-Routinen
avr/ina90.h Kompatibilität mit IAR-AVR-Compiler
avr/interrupt.h sei(), cli(), ...
avr/io.h --> inttypes.h, io*.h
avr/io*.h SFRs, SIG_****, SPM_PAGESIZE, RAMEND, XRAMEND, E2END, FLASHEND
avr/parity.h [*] Parität
avr/pgmspace.h Zugriff aufs Flash: Byte lesen, PROGMEM, prog_char, prog_uint8_t, ...
avr/portpins.h Makros für Port-Pins
avr/signal.h [**] Makros SIGNAL() und INTERRUPT(), ...
avr/sleep.h Power-Safe
avr/twi.h [*] I2C
avr/wdt.h Watchdog

util/crc16.h Prüfsumme CRC16
util/delay.h Verzögerungsschleifen für kurze, exakte Verzögerungen
util/parity.h Parität
util/twi.h I2C

[*] bei neueren avr-gcc-Versionen in util
[**] entfällt bei neueren avr-gcc-Versionen. Stattdessen avr/interrupt.h verwenden
</pre>

==Anwendungs-spezifisch==
Eigene Header, die nur innerhalb eigener Projekte gebraucht werden, includet man mit
#include "..."
Auch hier darf man Unterverzeichnisse angeben oder ins übergeordnete Verzeichnis:
#include "../../mein-zeug.h"

=Optimierungen, Tipps & Tricks=

Beim Programmieren in C möchte man sich möglichst wenig mit der Codeerzeugung selbst auseinandersetzen. Man verwendet ja gerade deshalb einen Compiler und programmiert nicht in Assembler, weil man sich nicht um Register-Belegungen o.ä. kümmern will, sondern nur um die zu lösende Aufgabe.

GCC erzeugt zwar recht guten Code, aber er ist nicht perfekt. Gerade auf Systemen wie AVR mit nur sehr begrenzten Resourcen muss man daher dem Compiler hilfreich zur Seite stehen, wenn man noch dichteren/schnelleren Code erhalten möchte.

:''"Unlike most other C compilers, GCC allows you to use -g with -O. The shortcuts taken by optimized code may occasionally produce surprising results: some variables you declared may not exist at all; flow of control may briefly move where you did not expect it; some statements may not be executed because they compute constant results or their values were already at hand; some statements may execute in different places because they were moved out of loops.''

:''Nevertheless it proves possible to debug optimized output. This makes it reasonable to use the optimizer for programs that might have bugs."''

Um das Ergebnis zu beurteilen, hilft ein Blick ins Listfile.
Siehe dazu auch die Abschnitte
"[[Hallo Welt für AVR (LED blinken)#Listfile erstellen|Listfile erstellen]]"
und
"[[Hallo Welt für AVR (LED blinken)#Die Größe ermitteln|Die Größe ermitteln]]"
im [[Hallo Welt für AVR (LED blinken)|Hallo Welt für AVR]].

==Optimierungsgrad==
Als Optimierungsgrad erweist sich <tt>-Os</tt> (Optimize for Size) als der beste, evtl. noch <tt>-O2</tt>. Ohne Angabe eines Optimierungsgrades wird nicht optimiert, was gleichbedeutend mit der Option <tt>-O0</tt> ist. Abzuraten ist von der maximalen Optimierung <tt>-O3</tt>, die wegen function inlining und loop unrolling zu sehr breitem Code führt und für AVR absolut nicht angesagt ist.

==Vermeide printf, scanf, malloc==
Funktionen von diesem Kaliber sind die absoluten Platz- und Zeitfresser.

Alternativen findet man reichlich in der <tt>avr-libc</tt> wie <tt>itoa</tt> und <tt>atoi</tt>.
Und für <tt>malloc</tt> und Konsorten sind dynamische Arrays und das Compiler-Builtin <tt>__builtin_alloca</tt> effizientere Alternativen, siehe auch im Abschnitt "[[avr-gcc#Dynamische Speicherallokierung|Dynamische Speicherallokierung]]".

==Konstante Strings ins Flash==
Konstante Strings, wie sie zu Ausgabezwecken Verwendung finden, werden im Programm oft nicht verändert und brauchen nicht SRAM zu belegen (und damit auch Flash, von wo aus sie vom Startup-Code ins SRAM kopiert werden), sondern gehören ins Flash!

Entsprechende Routinen, um auf Strings im Flash zuzugreifen, tragen die Suffix <tt>_P</tt>, wie z.B. <tt>strcmp_P</tt> mit dem Prototyp
extern int *strcmp_P (char *, const prog_char *)
Die Implementierungen befinden sich in der <tt>avr-libc</tt>.

'''Anwendung:'''
#include <avr/pgmspace.h>

const prog_char str_p[] = "Ein String im Flash";
const char str2_p[] PROGMEM = "Noch ein String im Flash";
...
{{ccomment|String im SRAM mit String im Flash vergleichen}}
if (!strcmp_P (str_sram, str_p))
{
{{ccomment|mach was bei Gleichheit}}
}

{{ccomment|"foo" wird im RAM angelegt. Ineffizient für konstante Strings!}}
{{ccomment|Beachte, daß damit strcmp (nicht strcmp_P) benutzt werden muss.}}
if (!strcmp (str_sram, "foo"))
{
{{ccomment|mach was bei Gleichheit}}
}

{{ccomment|PSTR bewirkt, daß die String-Konstante "foo"}}
{{ccomment|im Flash angelegt wird}}
if (!strcmp_P (str_sram, PSTR ("foo"))
{
{{ccomment|mach was bei Gleichheit}}
}
...
}

===Sprungtabelle===
Genauso macht man auch eine Sprungtabelle, um anhand von Kommando-Strings dazugehörige Funktionen ausführen zu lassen:
#include <avr/pgmspace.h>

int func1 (int arg)
{
...
}

#define TEXT_LEN 15

{{ccomment|Die Kommandostruktur}}
typedef struct
{
int (*func)(int); {{ccomment|Zeiger auf die auszuführende Funktion}}
int arg; {{ccomment|das Argument, das mitübergeben wird}}
char text[1+TEXT_LEN]; {{ccomment|Text, maximal TEXT_LEN Zeichen lang}}
} command_t;

{{ccomment|Das Array mit den Kommandos.}}
{{ccomment|Die funcx sind vom Prototyp (z.B. func1 oben)}}
{{ccomment|int funcx (int arg);}}
const command_t commands[] PROGMEM =
{
{ func1, 0, "Befehl 1" },
{ func2, 3, "Befehl für func2" }
};

{{ccomment|Sucht in commands[] nach text und führt gegebenenfalls}}
{{ccomment|die dazugehörige Funktion funcx mit Argument arg aus.}}
{{ccomment|Liefert den Rückgabewert von funcx}}
{{ccomment|oder -1, falls text nicht gefunden wurde.}}
int execute (const char *text)
{
{{ccomment|Schleifenvariable}}
unsigned char i;

{{ccomment|Wandert durch das Array mit Kommando-Strukturen}}
const command_t * cmd = commands;

{{ccomment|sizeof wird von gcc ausgewertet und ist wie eine Konstante,}}
{{ccomment|denn beide sizeofs sind zur Compilezeit bekannt}}
for (i=0; i < sizeof(commands) / sizeof(command_t); i++)
{
{{ccomment|Ist das der gesuchte String?}}
if (strcmp_P (text, cmd->text))
{
{{ccomment|Nein, dann weitersuchen}}
cmd++;
continue;
}

{{ccomment|Ja}}
int (*func)(int), arg;

{{ccomment|Dann Funktionszeiger und Argument besorgen,}}
func = (int(*)(int)) pgm_read_word (& cmd->func);
arg = (int) pgm_read_word (& cmd->arg);

{{ccomment|Funktion ausführen und deren Wert zurückliefern}}
return func (arg);
}

{{ccomment|text ist nicht in commands}}
return -1;
}

Nachteil dabei ist, daß jeder String den maximalen Platz von <tt>TEXT_LEN+1</tt> Zeichen belegt.
Falls man da noch weiter sparen will, dann kann man die Strings wieder ins Flash legen und ihre Adresse in der Struktur merken. Dadurch belegt ein String nur noch Länge+3 Zeichen (+3 wegen 1 Endezeichen und 2 Bytes für seine in der Struktur gemerkte Adresse). Die Definition der Tabelle wird aber umständlicher, weil jeder String einzeln angegeben werden muss:
#include <avr/pgmspace.h>

{{ccomment|Die Kommandostruktur}}
typedef struct
{
...
char * text; {{ccomment|Zeiger auf Text}}
} command_t;

const prog_char str_1[] = "Befehl 1";
const prog_char str_2[] = "Befehl für func2";

const command_t commands[] PROGMEM =
{
{ func1, 0, str_1 },
{ func2, 3, str_2 }
};

{{ccomment|Sucht in commands[] nach text und führt gegebenenfalls}}
{{ccomment|die dazugehörige Funktion funcx mit Argument arg aus.}}
{{ccomment|Liefert den Rückgabewert von funcx}}
{{ccomment|oder -1, falls text nicht gefunden wurde.}}
int execute (const char *text)
{
{{ccomment|Schleifenvariable}}
unsigned char i;

{{ccomment|Wandert durch das Array mit Kommando-Strukturen}}
const command_t * cmd = commands;

{{ccomment|sizeof wird von gcc ausgewertet und ist wie eine Konstante,}}
{{ccomment|denn beide sizeofs sind zur Compilezeit bekannt}}
for (i=0; i < sizeof(commands) / sizeof (command_t); i++)
{
const prog_char * text_P;

{{ccomment|Liest die Startadresse von str_x}}
text_P = (const prog_char *) pgm_read_word (& cmd->text);

{{ccomment|Ist das der gesuchte String?}}
if (strcmp_P (text, text_P))
{
...

==Lokale Variablen verwenden==

Beim Manipulieren globaler Variablen kann es günstig sein, diese in eine lokale Variable zu kopieren, dort zu verändern, und sie danach wieder zu schreiben
<pre>
char var;

void foo1()
{
var++;
if (var > 10)
var = 1;
}
</pre>
Dadurch wird einmal unnötig gespeichert (der dritte Befehl kann vermieden werden).
<pre>
foo1:
lds r24,var ; *movqi/4 [length = 2]
subi r24,lo8(-(1)) ; addqi3/2 [length = 1]
sts var,r24 ; *movqi/3 [length = 2]
cpi r24,lo8(11) ; cmpqi/2 [length = 1]
brlt .L3 ; branch [length = 1]
ldi r24,lo8(1) ; *movqi/2 [length = 1]
sts var,r24 ; *movqi/3 [length = 2]
.L3:
ret
</pre>
Indem man eine lokale Variable (<tt>var2</tt>) verwendet für die Änderung von <tt>var</tt> vermeidet man dies:
<pre>
char var;

void foo2()
{
char var2 = var;

var2++;
if (var2 > 10)
var2 = 1;

var = var2;
}
</pre>
Dadurch wird erst am Ende gespeichert. <tt>var2</tt> lebt in Register <tt>r24</tt>.
<pre>
foo2:
lds r24, var ; *movqi/4 [length = 2]
subi r24,lo8(-(1)) ; addqi3/2 [length = 1]
cpi r24,lo8(11) ; cmpqi/2 [length = 1]
brlt .L2 ; branch [length = 1]
ldi r24,lo8(1) ; *movqi/2 [length = 1]
.L2:
sts var, r24 ; *movqi/3 [length = 2]
ret
</pre>

Bei diesem einfachen Beispiel spart man lediglich eine Instruktion. Bei komplexeren Rechnungen oder längeren Datentypen kann es aber durchaus lohnender sein, in lokale Register zu kopieren.

==Arithmetik==

=== Daten zerlegen/zusammensetzen ===

In systemnahen Programmen hat man oft was Problem, auf die einzelnen Bytes oder Bitfelder einer grösseren Datenstruktur zuzugreifen. Indem man sich ein Komposit baut, das die gewünschten Strukturen überlagert, kann man effizient z.B. auf Bytes zugreifen. Ausnahme sind Bitfelder, deren Verwendung etwas breiten Code ergibt. Bitfelder "von Hand" zu manipulieren, ist da manchmal effizienter, führt jedoch zu schlecht lesbarem Code.

Oft benötigt wird der Zugriff auf die einzelnen Bytes eines <tt>int</tt>, also der Zugriff auf die Bytes eines 16-Bit-Wertes:

typedef union
{
unsigned char asByte[2];
unsigned short asWord;
int asInt;
} data16_t;

data16_t data;
...
int foo;
uint8_t wert;

data.asInt = foo;
wert = data.asByte[1]; {{ccomment|die oberen 8 Bits von foo}}

Ein komplexeres Beispiel, das noch mehr Datentypen überlagert:
typedef ... foo_t;

typedef union
{
unsigned char byte[4]; {{ccomment| Zugriff als Bytes (8 Bit) }}
unsigned short word[2]; {{ccomment| Zugriff als Words (16 Bit) }}
signed long slong; {{ccomment| Zugriff als signed long (32 Bit) }}

struct {{ccomment| Zugriff auf einzelne Bitgruppen }}
{
unsigned bit_0_3 : 4; {{ccomment| 4 Bits (0..3) }}
unsigned bit_4_8 : 5; {{ccomment| 5 Bits (4..8) }}
unsigned bit_9_21 : 13; {{ccomment| 13 Bits (9..21) }}
unsigned bit_22_31: 10; {{ccomment| 10 Bits (22..31) }}
};

foo_t foo; {{ccomment| Zugriff als foo-Struktur }}
} data_t;

...
{
data_t data;

data.byte[2] = 12; {{ccomment| setzt byte 2 auf 12 }}
data.bit_4_8 = 0x1f; {{ccomment| setzt bits 4..8 (5 Stück) alle auf 1 }}

int anInt = data.foo.anInt; {{ccomment| liest ein Feld von foo (hier ein int) }}
...
}

===libgcc2 verwenden===

In der libgcc2 sind einige Arithmetik-Routinen in Assembler implementiert. Dazu gehören ein paar Algorithmen zu Division (mit Rest) und Multiplikation.

Von diesen Algorithmen werden durch die avr-libc jedoch nur zwei Strukturen und Funktionen veröffentlicht: <tt>div_t</tt> und <tt>ldiv_t</tt> resp. die Funktionen <tt>div()</tt> und <tt>ldiv()</tt>. Siehe dazu deine Dokumentation zur avr-libc. Damit kann man Quotient und zusätzlich den Rest bei einer Division 16/16 bzw. 32/32 berechnen lassen; den Rest bekommt man quasi kostenlos als Nebenprodukt. Das ist praktisch, wenn man z.b. eine Zahl in Dezimaldarstellung umwandeln möchte oder von/nach [[BCD]].

Zusätzlich zu den via avr-libc veröffentlichten Funktionen gibt es aber noch Routinen, die z.B. auf 8-Bit-Werten operieren oder mit <tt>unsigned</tt> Typen und dementsprechend effizienter sind.

'''Beispiel: Umwandeln nach Dezimalstring'''

Hier ein Beispiel, das Division mit Rest für <tt>unsigned short</tt> verwendet, um eine 16-Bit-Zahl in Dezimaldarstellung zu wandeln:

{{ccomment| Struktur definieren und Funktion bekannt machen }}
typedef struct
{
unsigned short quot;
unsigned short rem;
} udiv_t;

extern udiv_t udiv (unsigned short, unsigned short) __asm__("__udivmodhi4");

{{ccomment| 5 Ziffern (0...65535) und evtl. noch eine führende 0 }}
#define DIGITS 6

{{ccomment| +1 wegen String-Ende (wird im Startup auf 0 gesetzt) }}
char string[DIGITS+1];

{{ccomment| Wandelt zahl in Dezimaldarstellung um. }}
{{ccomment| Der return-Wert zeigt irgendwo ins string[]-Array. }}
{{ccomment| string[] wird verändert. }}
char* toString (unsigned short zahl)
{
{{ccomment| s zeigt auf das Ende von string }}
{{ccomment| string wird von hinten nach vorne gefüllt }}
char *s = string + DIGITS;

{{ccomment| qrem enthält Quotient (quot) und Rest (rem) der Divisionen }}
udiv_t qrem = {.quot = zahl};

do
{
{{ccomment| Division mit Rest durch 10 }}
{{ccomment| quot: Ergebnis für den nächsten Durchlauf }}
{{ccomment| rem: Rest ist die Ziffer im 10er-System }}
qrem = udiv (qrem.quot, 10);

{{ccomment| Ziffer in Zeichen wandeln und speichern }}
*(--s) = '0' + qrem.rem;
}
while (0 != qrem.quot);

{{ccomment| Falls eine führende '0' gespeichert wurde: weg damit }}
{{ccomment| ausser zahl war selbst schon 0 }}
if (*s == '0' && *(s+1) != '\0')
s++;

return s;
}

Falls man eine Division und/oder Rest für 8-Bit braucht, dann geht für <tt>unsigned</tt> analog.

'''Beispiel: BCD-Umrechnung'''

Wandeln einer 8-Bit-Zahl <tt>0 <= num < 100</tt> nach [[BCD]]

typedef struct
{
unsigned char quot; {{ccomment| Quotient }}
unsigned char rem; {{ccomment| Rest (remainder) }}
} udiv8_t;

extern udiv8_t udiv8 (unsigned char, unsigned char) __asm__ ("__udivmodqi4");

{{ccomment| Wandelt num nach BCD um, 0 <= num <= 99 }}
{{ccomment| return-Wert ist dann 0x0 <= return <= 0x99 }}
unsigned char to_bcd (unsigned char num)
{
udiv8_t qrem = udiv8 (num, 10);

return (unsigned char) (qrem.quot << 4) | qrem.rem;
}

===Division durch Multiplikation===
===Vermeiden von float und double===

=Inkompatibilität=

[[GCC]] – und somit auch avr-gcc – werden ständig weiter entwickelt. Dies betrifft das Beheben von Fehlern, die Unterstützung neuer Architekturen/Sprachen/Betriebssysteme, Implementierung neuer Optimierungsalgorithmen, Vereinheitlichungen, etc.

Leider führt dies auch zu Inkompatibilitäten verschiedener avr-gcc-Versionen untereinander, und eine C-Quelle, die mit einer Version von avr-gcc fehler- und warnungsfrei übersetzt werden kann, ist mit einer anderen Version möglicherweise nicht compilierbar.

Die avr-gcc Version kann man anzeigen lassen, indem man in einer Shell/Eingabeaufforderung eintippt
avr-gcc -v

;<tt>#include <avr/signal.h></tt>: In Versionen bis 3.4.4 werden in dieser Header-Datei u.a. die Makros <tt>SIGNAL()</tt> und <tt>INTERRUPT()</tt> definiert, die man braucht, wenn man eine C-Funktion als Interrupt-Routine ([[ISR]]) kennzeichnen will. In neueren Versionen ab 3.4.5 sind diese Definitionen in den Header <tt>avr/interrupt.h</tt> gewandert, wo auch Makros wie <tt>sei()</tt> und <tt>cli()</tt> definiert werden. Die Inkludierung von <tt>avr/signal.h</tt> in den neueren avg-gcc Versionen führt zu einer Warnung, irgendwann vielleicht sogar zu einem Fehler, weil die Datei nicht mehr bei avr-gcc dabei ist und daher nicht mehr gefunden wird.
: '''Verwendet man bei einer älteren avr-gcc-Version <tt>SIGNAL</tt> bzw. <tt>INTERRUPT</tt> ohne <tt>avr/signal.h</tt> zu includen, wird u.U. stillschweigend falscher Code erzeugt.'''

;<tt>#include <util/...h></tt>: In <tt>util</tt> stehen jetzt Header wie <tt>util/parity.h</tt> oder das vielverwendete <tt>util/delay.h</tt>, die vormals im Include-Unterverzeichnis <tt>avr</tt> zu finden waren.

;Interrupt Service Routinen: Auch die API zur Definition von [[ISR]]s hat sich von avr-gcc Version 3.x zur Version 4.x geändert:
:'''avr-gcc 3.x'''
::{|
<pre>
SIGNAL (SIG_INTERRUPT0)
{
/* Interrupt Code */
}

INTERRUPT (SIG_OVERFLOW0)
{
/* Interrupt Code */
}
</pre>
|}

:'''avr-gcc 4.x'''
::{|
<pre>
ISR (INT0_vect)
{
/* Interrupt Code */
}

void TIMER0_OVF_vect (void) __attribute__((interrupt));
void TIMER0_OVF_vect (void)
{
/* Interrupt Code */
}
</pre>
|}

=Bugs=

==== Bit 7 bei SFR-Zugriff ====

Bei Sequenzen wie
PORTB &= ~ (1 << 7);
PORTD &= ~ (1 << 7);

macht avr-gcc eine CSE-Optimierung (common subexpression elimination). Er legt die Konstante 127 (<tt>~(1 << 7)</tt>) in ein Register und verwendet den Registerinhalt, anstatt die Konstante direkt zu verwenden.

Das führt dazu, daß statt der gewünschten Befehlsfolge
; Sequenz 1
cbi 37-0x20, 7
cbi 43-0x20, 7
Sequenzen folgender Gestalt erzeugt werden:
; Sequenz 2
ldi r18, lo8(127) ; 127 nach R18

in r19, 37-0x20 ; PORTB nach R19 lesen
; Wird hier eine ISR ausgeführt, die PORTB verändert, dann wird die
; Änderung mit dem folgenden OUT überschrieben
and r19, r18 ; oberstes Bit löschen
; dito
out 37-0x20, r19 ; PORTB schreiben

in r19, 43-0x20 ; analog
and r19, r18
out 43-0x20, r19

Abgesehen davon, daß Sequenz 2 deutlich mehr Programmspeicher und Laufzeit benötigt als Sequenz 1, kann es zu folgendem Fehler kommen:

Bei der zweiten Codesequenz erfolgt der Zugriff auf die SFRs nicht atomar. Wird der C-Code in einem Programm ausgeführt, das in einer [[ISR]] zB Port B3 verändert und wird diese ISR zwischen dem IN und dem OUT Befehl ausgeführt, dann überschreibt der OUT-Befehl den Wert von PORTB und die Aktion für Port B3 in der ISR wird wieder rückgängig gemacht. Das ist dann ein Programmfehler.

Damit das Problem zum Tragen kommt, müssen mehrere Bedingungen erfüllt sein:
* Bei mindestens zwei C-Befehlen wird der Wert 127 als 8-Bit-Wert benötigt. Das ist zB auch der Fall, wenn dieser Wert nur gespeichert wird oder modulo 0x80 gerechnet wird.
* Mindestens einer dieser Befehle löscht Bit 7 eines SFR aus dem bitadressierbaren I/O-Bereich. (Ausser PORTx oder DDRx sind in diesem Bereich noch weitere SFR untergebracht.)
* Im Programm wird auf unterschiedlichen [[Interrupt]]-Ebenen auf dieses SFR zugegriffen und die oben gezeigt Stelle kann von der ISR unterbrochen werden.
* Die beiden C-Befehle müssen nicht unmittelbar aufeinander folgen. Es können auch andere C-Befehle dazwischen stehen.

Bei den meisten Programmen wird das angesprochene Problem nicht zu einem Fehler führen. Falls doch, kann man dem begegnen mit folgenden

;Workarounds:
* Die C-Stelle wird in CLI/SEI eingeschlossen und kann damit nicht mehr von einer ISR unterbrochen werden.
* Alternativ schreibt man vor und nach jedem problematischen SFR-Zugriff folgendes Kommando:
:{|
|-
|
__asm volatile (""::);
|}
:Dieses Kommando erzeugt keine Assembler-Instruktionen, vermeidet aber die unerwünschte "Optimierung" im gcc, und es entsteht Code gemäß Sequenz 1.
* Alternativ definiert man sich ein Makro, mit dem man die Portzugriffe tätigt:
:{|
|-
|
#define CBI(A,B) __asm volatile ("cbi\t%0, %1" :: "M" (_SFR_IO_ADDR(A)), "M" (B))
|}
:Und löscht das Bit mit
:{|
|-
|
CBI (PORTB, 7);
|}

==== <tt>__builtin_return_address(0)</tt> ====
ist entgegen der Spezifikation nicht implementiert und liefert in der Regel ein falsches Ergebnis.

;Workaround:

(hier für eine ISR):
#include <stdarg.h>
#include <avr/interrupt.h>

{{ccomment|The return address}}
unsigned short volatile return_addr;

{{ccomment|Define our special SIGNAL (INTERRUPT analoguous)}}
#define SIGNAL_BRA(signame,var) \
void signame (unsigned short var, ...) __attribute__ ((signal)); \
void signame (unsigned short var, ...)

#define SWAP_BYTES(x) (((x) >> 8) | ((x) << 8))

SIGNAL_BRA (SIG_OUTPUT_COMPARE1A, dummy)
{
{
va_list vlist;
va_start (vlist, dummy);

{{ccomment|Get the return address from the stack}}
dummy = va_arg (vlist, unsigned short);

{{ccomment|Convert stack address to code location}}
addr = SWAP_BYTES(dummy) << 1;
va_end (vlist);
}
{{ccomment|ISR Code}}
}

==== gcc 4.x ====

In der 4er-Version gab es tiefgreifende interne Änderungen im Compiler; er ist noch instabil und kann momentan nicht für den Produktiv-Einsatz empfohlen werden (Stand 02/2006).

Die Auswirkungen der Optimierungen auf das Zielsystem <tt>avr</tt> bleibt abzuwarten, dürfte aber nicht wesentlich sein. Die neue 4-er Version wurde u.a. deshalb aufgelegt, um mit dem Intel-Compiler gleichzuziehen – also im Hinblick auf das Zielsystem <tt>i386</tt>) gemacht.

Auch nach dem Release der 4-er Version wird die 3-er Version weiterentwickelt, da erst nach 1-2 Jahren nach Release einer neuer Major-Version ein Umstieg anzuraten ist und auch erst dann getätigt wird (zumindest im professionellen Bereich).

=Abkürzungen und Bezeichnungen=
; [[GCC]]: GNU Compiler Collection
; gcc: GNU C-Compiler
; GPR: '''G'''eneral '''P'''urpose '''R'''egister
; [[ISR]]: [[Interrupt|'''I'''nterrupt]] '''S'''ervice '''R'''outine
; [[IRQ]]: '''I'''nterrupt '''R'''e'''q'''uest
; Prolog/Epilog: Code am Anfang/Ende jeder Funktionen/ISR, der dazu dient, verwendete Register zu sichern, den Stack-Frame für lokale [[Variable|Variablen]] anzulegen (falls benötigt), Stackpointer zu setzen, zurück zu springen (<tt>ret</tt>, <tt>reti</tt>), etc.
; SFR: '''S'''pecial '''F'''unction '''R'''egister
; Target: Zielsystem, in unserem Falle avr

=Siehe auch=
* [[C-Tutorial]]
'''Code-Beispiele'''
* [[Hallo Welt für AVR (LED blinken)]] - ein erstes Beispiel für avr-gcc
*[[:Kategorie:Quellcode_C|C-Codebeispiele]]
* [[Fallstricke bei der C-Programmierung]]

'''Details'''
* [[Inline-Assembler in avr-gcc|Inline-Assembler]]
* [[avr-gcc/Interna|Interna von avr-gcc]]

'''Installation (Linux)'''
* [[Linuxdistribution_Avr-live-cd]]
* [[avr-gcc und avrdude installieren]]
'''Sonstiges'''
* [[WinAVR]]
* [[Speicherverbrauch bestimmen mit avr-gcc]]
* [[Compiler]]
* [[Dev-Cpp IDE]]
* [[AVR]]
----
* [[Sourcevergleich]]
* [[Codevergleich AVR-Compiler]]

=Weblinks=
==Dokumentation==
* [http://gcc.gnu.org/onlinedocs/ GCC online documentation (en)] Offline findest du die Doku für gcc, cpp (Präprozessor) und avr-libc bei [[WinAVR]] in
:<pre><GCC_HOME>/doc/gcc/</pre>
: bzw.
:<pre><GCC_HOME>/doc/avr-libc/</pre>
:Online finden sich die Dokumente in
* [http://gcc.gnu.org/onlinedocs/gcc.pdf gcc.pdf (1900 kByte)] - Dokumentation des C/C++/Java-Compilers GCC (en)
* [http://gcc.gnu.org/onlinedocs/cpp.pdf cpp.pdf (470 kByte)] - Dokumentation des C-Präprozessors (en)
* [http://www.nongnu.org/avr-libc/user-manual/modules.html http://www.nongnu.org/avr-libc/user-manual] - Dokumentation zur avr-libc.

== Downloads==
* [http://sourceforge.net/projects/winavr/ WinAVR-Projekt bei sourceforge.net (en)]
* [http://cdk4avr.sourceforge.net/ avr-gcc und toolchain als Linux-Paket bei sourceforge.net (en)]
* [[Linuxdistribution_Avr-live-cd]]
== Tipps, Installation ==
*[http://www.nongnu.org/avr-libc/user-manual/install_tools.html ''"Installing the GNU Tool Chain"''] Hilfe zum Build und Installation von GCC, binutils, etc unter Linux
* Im GCC-Handbuch, siehe [[#Dokumentation|Dokumentation]].
* [http://www.linuxfocus.org/Deutsch/November2004/article352.shtml www.linuxfocus.org (Artikel)] - Tipps zu Build und Installation von avr-gcc, binutils und avr-libc unter Linux
* [http://users.rcn.com/rneswold/avr/ Rich Neswold: ''A GNU Development Environment for the AVR Microcontroller'']
* [http://www.mikrocontroller.net/topic/24166 www.mikrocontroller.net (Foren-Beitrag)] - Installation von GCC und Toolchain unter Mac OS X
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=125603#125603 www.roboternetz.de (Foren-Beitrag)] ''avrgcc + avrdude installieren''

== Sonstiges ==
* [http://gcc.gnu.org/ Offizielle Homepage von GCC (en)]
* [http://de.wikipedia.org/wiki/GNU_Compiler_Collection GCC in der deutschen Wikipedia]
* [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial avr-gcc-Tutorial auf mikrocontroller.net]
* [http://www.avrfreaks.net/AVRGCC/ avr-gcc bei avrfreaks.net (en)]
* [http://savannah.nongnu.org/projects/avr-libc/ Nützliche GCC Runtime-Libary]

=Autor=

--[[Benutzer:SprinterSB|SprinterSB]] 11:27, 7. Dez 2005 (CET)

[[Kategorie:Grundlagen]]
[[Kategorie:Microcontroller]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]

C-Tutorial

2007-03-18T08:39:46Z

Inrfb2: /* Reihenfolge der Auswertung */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|Zugriff auf Struktur-Komponenten}}
hubert.alter = 32;
klaus.alter = hubert.alter + 1;

'''Hinweis:'''
Der eventuell etwas lästige Gebrauch von <tt>struct</tt> kann schon bei der Definition der Struktur vermieden werden.
Der Definition ist ein <tt>typedef</tt> voranzustellen. Der Definition folgt dann ein gültiger (und auch eindeutiger) C-Name.

'''Syntax:'''
typedef struct {{Bezeichner}}
{
{{Deklaration}}
{{Deklaration}}
...
} {{Bezeichner}} ;

'''Beispiel:'''
{{comment|Definition der Struktur '_Mensch' bzw. 'Mensch'}}
struct _Mensch
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
} Mensch;

Jetzt sind folgende Deklarationen identisch:
struct _Mensch {{Bezeichner}};
Mensch {{Bezeichner}};

Ist der Struktuname nicht notwendig (im Beispiel oben <tt>_Mensch</tt>), kann auch kürzer geschrieben werden:

'''Syntax:'''
typedef struct
{
{{Deklaration}}
{{Deklaration}}
...
} {{Bezeichner}} ;

'''Beispiel:'''
{{comment|Definition der Struktur 'Mensch'}}
struct
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
} Mensch;

In diesem Fall ist lediglich die {{Deklaration}} <tt>Mensch {{Bezeichner}};</tt> gültig.

Der Hinweis gilt sinngemäß auch für die Definition <tt>union</tt> im nachfolgenden Abschnitt.

===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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Sicher jedoch ist, dass nicht jeder Programmierer diese Regel jederzeit im Kopf hat.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

Die Reihenfolge der Auswertung von Funktionsargumenten ist in der ANSI-Spezifikation nicht angegeben und daher compilerabhängig. Von Konstrukten wie
{
int i=0;
func (i++, i++);
}
ist also dringend abzuraten!

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

;Ein Hinweis am Rande: Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang. Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen. Siehe auch [[#Zeiger auf Funktionen|Zeiger auf Funktionen]].

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Variable Argumentanzahl==
== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert einen Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. 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]</tt>. 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 sollen. Falls Dir solch ein Syntax-Baustein begegnet, kannst Du ihn anklicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, werdendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

= Autoren=
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

=Quellen=
* Kernighan und Ritchie
* Christian Wirth, C-Tutorial
* Prof. Dr. J. Dankert Ausführungen
* W. Alex, Einführung in C/C++
* Peter Baeumle-Courth, ANSI-C im Überblick

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

C-Tutorial

2007-03-14T12:23:59Z

Inrfb2: /* Strukturen */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|Zugriff auf Struktur-Komponenten}}
hubert.alter = 32;
klaus.alter = hubert.alter + 1;

'''Hinweis:'''
Der eventuell etwas lästige Gebrauch von <tt>struct</tt> kann schon bei der Definition der Struktur vermieden werden.
Der Definition ist ein <tt>typedef</tt> voranzustellen. Der Definition folgt dann ein gültiger (und auch eindeutiger) C-Name.

'''Syntax:'''
typedef struct {{Bezeichner}}
{
{{Deklaration}}
{{Deklaration}}
...
} {{Bezeichner}} ;

'''Beispiel:'''
{{comment|Definition der Struktur '_Mensch' bzw. 'Mensch'}}
struct _Mensch
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
} Mensch;

Jetzt sind folgende Deklarationen identisch:
struct _Mensch {{Bezeichner}};
Mensch {{Bezeichner}};

Ist der Struktuname nicht notwendig (im Beispiel oben <tt>_Mensch</tt>), kann auch kürzer geschrieben werden:

'''Syntax:'''
typedef struct
{
{{Deklaration}}
{{Deklaration}}
...
} {{Bezeichner}} ;

'''Beispiel:'''
{{comment|Definition der Struktur 'Mensch'}}
struct
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
} Mensch;

In diesem Fall ist lediglich die {{Deklaration}} <tt>Mensch {{Bezeichner}};</tt> gültig.

Der Hinweis gilt sinngemäß auch für die Definition <tt>union</tt> im nachfolgenden Abschnitt.

===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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Sicher jedoch ist, dass nicht jeder Programmierer diese Regel jederzeit im Kopf hat.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

'''Quellen:'''

Peter Baeumle-Courth, ANSI-C im Überblick 
W. Alex, Einführung in C/C++

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

;Ein Hinweis am Rande:
Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang.
Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger
zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen.

'''Quelle:'''
W. Alex, Einführung in C/C++

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Variable Argumentanzahl==
== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert einen Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. 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]</tt>. 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 sollen. Falls Dir solch ein Syntax-Baustein begegnet, kannst Du ihn anklicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, werdendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

'''Autoren'''
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

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

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

C-Tutorial

2007-03-14T12:22:18Z

Inrfb2: /* Strukturen */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|Zugriff auf Struktur-Komponenten}}
hubert.alter = 32;
klaus.alter = hubert.alter + 1;

'''Hinweis:'''
Der eventuell etwas lästige Gebrauch von <tt>struct</tt> kann schon bei der Definition der Struktur vermieden werden.
Der Definition ist ein <tt>typedef</tt> voranzustellen. Der Definition folgt dann ein gültiger (und auch eindeutiger) C-Name.

'''Syntax:'''
typedef struct {{Bezeichner}}
{
{{Deklaration}}
{{Deklaration}}
...
} {{Bezeichner}} ;

'''Beispiel:'''
{{comment|Definition der Struktur '_Mensch' bzw. 'Mensch'}}
struct _Mensch
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
} Mensch;

Jetzt sind folgende Deklarationen identisch:
struct _Mensch {{Bezeichner}};
Mensch {{Bezeichner}};

Ist der Struktuname nicht notwendig (im Beispiel oben <tt>_Mensch</tt>), kann auch kürzer geschrieben werden:

'''Syntax:'''
typedef struct
{
{{Deklaration}}
{{Deklaration}}
...
} {{Bezeichner}} ;

'''Beispiel:'''
{{comment|Definition der Struktur 'Mensch'}}
struct
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
} Mensch;

In diesem Fall ist lediglich die {{Deklaration}} <tt>Mensch {{Bezeichner}};</tt> gültig.

===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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Sicher jedoch ist, dass nicht jeder Programmierer diese Regel jederzeit im Kopf hat.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

'''Quellen:'''

Peter Baeumle-Courth, ANSI-C im Überblick 
W. Alex, Einführung in C/C++

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

;Ein Hinweis am Rande:
Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang.
Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger
zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen.

'''Quelle:'''
W. Alex, Einführung in C/C++

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Variable Argumentanzahl==
== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert einen Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. 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]</tt>. 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 sollen. Falls Dir solch ein Syntax-Baustein begegnet, kannst Du ihn anklicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, werdendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

'''Autoren'''
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

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

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

C-Tutorial

2007-03-14T11:52:48Z

Inrfb2: /* Syntax-Bausteine */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Sicher jedoch ist, dass nicht jeder Programmierer diese Regel jederzeit im Kopf hat.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

'''Quellen:'''

Peter Baeumle-Courth, ANSI-C im Überblick 
W. Alex, Einführung in C/C++

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

;Ein Hinweis am Rande:
Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang.
Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger
zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen.

'''Quelle:'''
W. Alex, Einführung in C/C++

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Variable Argumentanzahl==
== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert einen Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. 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]</tt>. 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 sollen. Falls Dir solch ein Syntax-Baustein begegnet, kannst Du ihn anklicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, werdendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

'''Autoren'''
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

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

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

C-Tutorial

2007-03-14T11:44:29Z

Inrfb2: /* Syntax-Bausteine */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Sicher jedoch ist, dass nicht jeder Programmierer diese Regel jederzeit im Kopf hat.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

'''Quellen:'''

Peter Baeumle-Courth, ANSI-C im Überblick 
W. Alex, Einführung in C/C++

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

;Ein Hinweis am Rande:
Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang.
Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger
zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen.

'''Quelle:'''
W. Alex, Einführung in C/C++

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Variable Argumentanzahl==
== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert einen Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. 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]</tt>. 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 sollen. Falls Dir solch ein Syntax-Baustein begegnet, kannst Du ihn anclicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, werdendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

'''Autoren'''
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

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

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

C-Tutorial

2007-03-13T20:19:42Z

Inrfb2: /* Parameter von <tt>main</tt> */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Sicher jedoch ist, dass nicht jeder Programmierer diese Regel jederzeit im Kopf hat.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

'''Quellen:'''

Peter Baeumle-Courth, ANSI-C im Überblick 
W. Alex, Einführung in C/C++

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

;Ein Hinweis am Rande:
Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang.
Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger
zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen.

'''Quelle:'''
W. Alex, Einführung in C/C++

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Variable Argumentanzahl==
== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert einen Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. 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]</tt>. 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 sollen. Falls die solch ein Syntax-Baustein begegnet, kannst Du ihn anclicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, werdendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

'''Autoren'''
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

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

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

C-Tutorial

2007-03-13T19:13:39Z

Inrfb2: /* Reihenfolge der Auswertung */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Sicher jedoch ist, dass nicht jeder Programmierer diese Regel jederzeit im Kopf hat.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

'''Quellen:'''

Peter Baeumle-Courth, ANSI-C im Überblick 
W. Alex, Einführung in C/C++

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

;Ein Hinweis am Rande:
Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang.
Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger
zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen.

'''Quelle:'''
W. Alex, Einführung in C/C++

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Variable Argumentanzahl==
== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert einen Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement – wie in C üblich – das Element <tt><tt>argv[argc-1]</tt>. 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 sollen. Falls die solch ein Syntax-Baustein begegnet, kannst Du ihn anclicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, werdendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

'''Autoren'''
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

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

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

C-Tutorial

2007-03-13T11:49:25Z

Inrfb2: /* Aufruf */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Neben hat auch nicht jeder Programmierer diese Regel jederzeit im Kopf.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

'''Quellen:'''

Peter Baeumle-Courth, ANSI-C im Überblick 
W. Alex, Einführung in C/C++

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

;Ein Hinweis am Rande:
Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang.
Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger
zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen.

'''Quelle:'''
W. Alex, Einführung in C/C++

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Variable Argumentanzahl==
== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert einen Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement – wie in C üblich – das Element <tt><tt>argv[argc-1]</tt>. 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 sollen. Falls die solch ein Syntax-Baustein begegnet, kannst Du ihn anclicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, werdendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

'''Autoren'''
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

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

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

C-Tutorial

2007-03-13T11:45:39Z

Inrfb2: /* Aufruf */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Neben hat auch nicht jeder Programmierer diese Regel jederzeit im Kopf.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

'''Quellen:'''

Peter Baeumle-Courth, ANSI-C im Überblick 
W. Alex, Einführung in C/C++

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

Ein Hinweis am Rande: 
Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang.
Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger
zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen. 

'''Quelle:'''
W. Alex, Einführung in C/C++

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Variable Argumentanzahl==
== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert einen Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement – wie in C üblich – das Element <tt><tt>argv[argc-1]</tt>. 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 sollen. Falls die solch ein Syntax-Baustein begegnet, kannst Du ihn anclicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, werdendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

'''Autoren'''
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

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

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

C-Tutorial

2007-03-13T11:41:00Z

Inrfb2: /* Aufruf */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Neben hat auch nicht jeder Programmierer diese Regel jederzeit im Kopf.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

'''Quellen:'''

Peter Baeumle-Courth, ANSI-C im Überblick 
W. Alex, Einführung in C/C++

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

Ein Hinweis am Rande:
Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang.
Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger
zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen.

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Variable Argumentanzahl==
== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert einen Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement – wie in C üblich – das Element <tt><tt>argv[argc-1]</tt>. 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 sollen. Falls die solch ein Syntax-Baustein begegnet, kannst Du ihn anclicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, werdendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

'''Autoren'''
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

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

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

C-Tutorial

2007-03-13T11:36:53Z

Inrfb2: /* Reihenfolge der Auswertung */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Neben hat auch nicht jeder Programmierer diese Regel jederzeit im Kopf.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

'''Quellen:'''

Peter Baeumle-Courth, ANSI-C im Überblick 
W. Alex, Einführung in C/C++

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Variable Argumentanzahl==
== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert einen Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement – wie in C üblich – das Element <tt><tt>argv[argc-1]</tt>. 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 sollen. Falls die solch ein Syntax-Baustein begegnet, kannst Du ihn anclicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, werdendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

'''Autoren'''
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

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

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

C-Tutorial

2007-03-13T11:26:45Z

Inrfb2: /* Reihenfolge der Auswertung */

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.

==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;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: 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 "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, 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 <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" 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 <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> 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 <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> 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 <tt>return</tt> 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 "<tt>main</tt>". 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 – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-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!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|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)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"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 <tt>int</tt> 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, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

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

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== 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 <tt>int</tt> 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 <tt>char</tt>-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 <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> 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 <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> 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 <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> 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 <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

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

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-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:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

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

==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 <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> 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 – 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 <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> 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]; {{comment|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 "<tt>NZAHLEN</tt>" 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.

{{FarbigerRahmen|
'''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 (<tt>char</tt>) 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 "<tt>char feld[1024][1024]</tt>" 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:
<pre>
#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;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
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:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> 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 <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|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.
<pre>
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;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. 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 <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsignen short as_short[2];
unsignen char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|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 <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> 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;
{{comment|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|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> 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<tt>-</tt>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 <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
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 das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|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 <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|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 <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> 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 <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalt der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, daß <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, 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|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
;<tt>auto</tt>: 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 "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: 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|Deklaration und Definition]].
;<tt>static</tt>: 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 <tt>static</tt> 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.
;<tt>register</tt>: 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!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> 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. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | 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 <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> 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|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> 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 <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> 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 <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> 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:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
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 <tt>if</tt>-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 <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

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

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> 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 <tt>b</tt> im Feld <tt>a</tt> 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==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

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 [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente 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 <tt>*</tt> 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; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"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 <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

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

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> 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 <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Neben hat auch nicht jeder Programmierer diese Regel jederzeit im Kopf.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese 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 <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' 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 <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" 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 <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...

case konstante2:
{{Anweisung}}
{{Anweisung}}
...

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|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 <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

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

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> 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 (<tt>zahl1</tt> 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; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> 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 <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

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

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

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stellen Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen abenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

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

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==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 <tt>main</tt> 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. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>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.

<pre>
#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);
}
</pre>

==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|Zeiger]] übergeben werden.
# Werden [[#Strukturen|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);
{{comment|a ist immer noch 0}}

return 0;
}

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

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

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

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

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|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);
{{comment|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:

{{comment|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);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

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

==Variable Argumentanzahl==
== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==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 C-Compiler 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 <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

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

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert einen Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-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!

<pre>
#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;
}
</pre>

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

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

===strlen===
Die Funktion <tt>strlen</tt>, 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.

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

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

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

==Ein- und Ausgabe-Funktionen==

===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 <tt>printf</tt> (das '<tt>f</tt>' 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. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#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;
}
</pre>

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

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

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

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, 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 <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

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

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 <tt>zahl1</tt> 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 <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> 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").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" 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:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" 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 <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#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]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement – wie in C üblich – das Element <tt><tt>argv[argc-1]</tt>. 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 sollen. Falls die solch ein Syntax-Baustein begegnet, kannst Du ihn anclicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
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 selbstdefinierte 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 <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
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
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> 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.

=====<tt><Bedingung></tt>=====
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)

=====<tt><Lvalue></tt>=====
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 <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
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 [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
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 <tt>&</tt>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

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
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;
...
{{Label|ein_label}}:;
}

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

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparametrige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, werdendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{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. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| 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: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Schieben nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|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 
<tt>(long) ···</tt> 
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 <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

'''Autoren'''
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

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

=Siehe auch=
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]