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

C-Tutorial

2006-05-07T19:14:02Z

Johannuhrmann: /* Kontrollanweisungen */

Ein kurzer Einblick in die Programmiersprache C
=Allgemeines=
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 Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.

C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu 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.
<pre>
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

/* Anweisungen */
return 0;
}
</pre>

Die Beschreibung (die Erklärungen folgen):

;<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ücksichtige, 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 sozusagen 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. Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es dann also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als oft auch 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.
<pre>
/* void Definition von main ist nur beim Controller üblich
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main
* kein Fehler/Warnung erzeugt wird.
*/
void main(void)
{
...
}
</pre>
Was das bedeutet, lernen Sie in einem späteren Kapitel. Wichtig ist nur: ohne main ist kein Programm komplett, es lässt sich dann auch nicht ausführen.

=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":

<pre>
int main (void)
{ /* der Block "main" beginnt */
int zahl;

{ /* ein Block beginnt */
/* hier können Deklarationen und stehen Anweisungen stehen */
} /* der Block endet */

return 0;
} /* "main" endet */
</pre>

'''Bemerkung:'''
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, und welcher Art diese Daten sind. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können Sie alle möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können).

;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 ab!

===int, char, short, long (ganze Zahlen)===
In Variable dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, -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 recht 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>

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

=== 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 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: In Zukunft werden ich oft 1 als Synonym für "ungleich 0" verwenden. Bitte beachten Sie jedoch, das eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

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

==Zusammengesetzte Datentypen==
===Felder===
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 Felder, sogenannte ''Arrays'', zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits bekanntes Beispiel für ein Array ist ein String. Ein String ist nichts anderes als ein Array des Datentypes char.

'''Syntax:''' Datentyp Variablenname[Anzahl]

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

int main(void)
{
int i;
int zahlen[10]; /* zahlen[0] bis zahlen[9] !!! */

for (i=0; i<10; i++)
{
printf ("Bitte Zahl %d eingeben: ", i);
scanf ("%d", & zahlen[i]);
printf ("\n");
}
printf ("Super!\n");

for (i=0; i<10; i++)
printf ("Zahl %d ist: %d\n", i, zahlen[i]);

return 0;
</pre>

'''Bemerkungen:'''
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.

{{FarbigerRahmen|
'''Merke:'''
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!
}}

===Mehrdimensionale Felder===
Manchmal benötigen 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.

==Strings (Zeichenketten)==
Bei einem String handelt es sich um ein Array, das aus einzelnen Zeichen 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.

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

<pre>
struct Person {
char vname[20], nname[20];
char telnr[15];
int alter;
};
</pre>

'''Erklärung:'''
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden 4 Variablen angelege: 3 Strings und ein <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach
struct Person Variablenname;
an.

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:
<pre>
struct Person hubert;

hubert.alter = 32;
</pre>

==Zeiger==
Jede Variable steht an einer genau definierten Stelle im Speicher. Diese Stelle kann man in Erfahrung bringen. Wie man das macht und was das überhaupt für Vorteile bringt, erfahren Sie in diesem Abschnitt.
Ein Zeiger ist im Variable, in der eine Adresse gespeichert ist. Diese stellt eine bestimmte Position im Arbeitsspeicher dar. Hier sehen Sie, wie man einen Zeiger definiert und mit ihm arbeitet:

<pre>
#include <stdio.h>

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

zeiger = &zahl;
*zeiger = 12;

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

return 0;
</pre>

'''Erklärung:'''
Um einen Zeiger anzulegen, gibt man folgendes an: Datentyp, dann einen Stern (<tt>*</tt>), anschliessend den Namen (und einen Strichpunkt).
Um einen Zeiger auf eine bestimmte Zahl "zeigen" zu lassen, muß man dem Zeiger die Adresse einer Variablen zuordnen. Das funktioniert mittels des Adress-Operators <tt>&</tt> (<tt>zeiger = &zahl</tt>).
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operators" <tt>*</tt> (<tt>*zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

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

Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.
==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!
<pre>
int Zahl1, Zahl2;
char Zeichen;

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

return 0;
}
</pre>
;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 "wahr", ansonsten ist sie "unwahr".
intVariable = !0; /* entspricht "wahr" */
intVariable = 0; /* entspricht "unwahr" */

==Vergleich von Variablen==
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln:
<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>
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl.
intVariable = zahl1 <= zahl2;
das komplette Beispiel zeigt es deutlicher:
<pre>
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */

printf ("Ergebnis: %d\n", i);
</pre>
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").

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

Wichtig dabei ist, dass man Konstanten nur bei der Vereinbarung einen Wert zuweisen kann.
Da Konstanten gewöhnlich im gesamten Programm, zumindest einer Quelldatei genutzt werden, definiert man diese allerdings gewöhnlich außerhalb des main-Blockes entweder am Anfang eines Programmes, oder in einer sogenannten Header-Datei, die per <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; /* Zuweisung bei der Defininition der Variablen */

==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>: 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.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert.
Eine Variable ist so ein LValue, der etwas zugewiesen werden kann:
a = 1;
Hingegen ist <tt>a+1</tt> kein LValue, denn eine Zuweisung wie
a+1 = 2;
erzeugt einen Compilerfehler, der etwas lautet könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

==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 Eigenheit der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet.

Beispiel:
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */

<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,
die eine aufwändige Operation durchführt.
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.

Wo ist also der Unterschied? 
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.

==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:
<pre>
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */

/* z ist ein Zeiger auf eine Integervariable und enthält somit
die Speicheradresse einer Integervariablen
*/
int *z;

/* Verwendung des Adressoperators... */
z = &x; /* weise z die Speicheradresse von x zu */

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

/* da z auf x zeigt, hat auch x jetzt den Wert 6 */
</pre>

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

Statt
(*strukturZeiger).element
kann geschrieben werden
strukturZeiger->element
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

{{FarbigerRahmen |
'''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:

<pre>
int *z; /* z ist ein Zeiger auf einen Integer */

/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.
z enthält irgendeine(!) Adresse
*/

/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */
*z = *z + 1;
</pre>

Viele C-Compiler (z.B. gcc) 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'' durch, sondern unterdrückt nur die Compilerwarnungen oder
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in
eine Zahl oder umgekehrt zu wandeln:

<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 Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.
}}

==Komma Operator==
Mit einem <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.

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingte Zuweisung===
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;

==Blöcke==
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks.
Der Block muss un runden Klammern stehen:
int sum;
sum = ({
int i, s = 0;
for (i=1; i<= 100; i++)
s += i;
s;
});

Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc,
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer
Instruktion nicht machbar wäre:
<pre>
#define PSTR(s) \
({ \
static char __c[] PROGMEM = (s); \
__c; \
})
</pre>

==Reihenfolge der Auswertung==

=Kontrollanweisungen=

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

b1= b2 && b3;

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

b1= b2 || b3;

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

b1= !b2;

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

==<tt>if</tt>-Anweisung==
Syntax: IF (Bedingung) Anweisung;
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:

[[bild:ifthenelse.png]]

Und in C schreibt man:
<pre>
if (Bedingung) /* WENN */
{ /* DANN */
Anweisung1;
Anweisung2;
...
}
else
{ /* SONST */
Anweisung3;
Anweisung4;
...
}
</pre>
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.

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

<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki>

<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki>

Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.
}}

==<tt>switch</tt>-Anweisung==
Syntax:
<pre>
switch(ausdruck) {
case wert1:
Anweisungen1...
case wert2:
Anweisungen2...
case wert3:
Anweisungen3...
...
default:
Anweisungen4...
}
</pre>

Der <tt>ausdruck</tt> muss eine Ganzzahl (int) ergeben und wird dann der Reihe nach mit den Werten, die hinter
den <tt>case</tt>-Anweisungen angegeben sind verglichen. Bei einer Übereinstimmung werden alle Befehle ab der
zutreffenden Case-Anweisung ausgeführt. Stimmt der <tt>ausdruck</tt> mit keinem der Werte hinter <tt>case</tt>
überein, so wird der <tt>default</tt>-Abschnitt ausgeführt.

Auch die Anweisungen der folgenden <tt>case</tt>- und des <tt>default</tt>-Abschnitts werden ausgeführt, wenn die Anweisungen eines
<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, muss aber nach allen <tt>case</tt>-Abschnitten angegeben werden,
wenn er verwendet wird.

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

===<tt>while</tt>-Schleife===
'''Syntax:''' while (Bedingung) { Anweisung; }

Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block!

<pre>
Zahl1=0;
while (Zahl1<3)
{
Zahl1=Zahl1+1;
Zahl2=Zahl2*2;
}
</pre>

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.
===<tt>do</tt>-<tt>while</tt>-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. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird

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

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.

===<tt>for</tt>-Schleife===
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }

Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Ist die Bedingung nicht mehr erfüllt, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block.

Die gesammte Schleife wird solange durchgeführt, wie die Bedingung wahr ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.

Die Theorie ist schwer, die Praxis nicht so sehr. In der Schleife wird die Summe ungerader Zahlen kleinergleich 10 berechnet.

<pre>
int lauf;
int summe = 0;

for (lauf = 1; lauf <= 10; lauf = lauf+2 )
{
summe = summe + lauf;
}
</pre>
Das Äquivalent als <tt>while</tt>-Schleife:
<pre>
int lauf = 1; /* Anfangswerte */
int summe = 0;

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

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 hat, ist in <tt>summe</tt> nach der Schleife die Summe der ungeraden Zahlen von 1 bis kleinergleich 10 gespeichert.

'''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 = lauf+2</tt> bedeutet, dass <tt>lauf</tt> nach jedem Durchlauf um 2 erhöht wird.

=Ein- und Ausgabe=

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

Die dazu notwendige Funktione heisst <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").

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

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

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

<pre>
#include <stdio.h>

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

int main (void)
{
int zahl1, ergebnis;

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

ergebnis = hoch2 (zahl1);

printf ("%d hoch 2 = %d\n",zahl1, ergebnis);
printf ("5 hoch 2 = %d\n", hoch2(5));

return 0;
}
</pre>

'''Bemerkungen zum Programm:'''
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen.
Geschachtelte-Unterprogramme sind in Standard-C nicht möglich.
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Danach folgt der Name der Funktion (case-sensitiv!). Dann kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden und mittels Komma voneinander getrennt werden.
Im Block der Funktion können lokale Variablen definiert werden und alle Anweisungen ausgeführt werden.
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung <tt>return</tt> und dem Rückgabewert.
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an
variable = Funktion (Parameter);
Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

==Prozedur==
'''Syntax:''' <tt>void Name (Parameterliste)</tt>

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

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

<pre>
#include <stdio.h>

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

int main(void)
{
int zahl1 = 4;

ausgeben (23);
ausgeben (zahl1);

return 0;
}
</pre>

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

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

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen Sie beim Aufruf trotzdem die Klammern angeben. Beispiel für eine parameterlose Funktion <tt>foo</tt>:
foo();
}}

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

Entweder Sie schreiben alle Unterprogramme vor <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:
<pre>
void erhoehe (int x)
{
x = x + 1;
}

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

return 0;
}
</pre>

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 x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.

<pre>
void erhoehe (int *x)
{
/* erhöhe den Wert an der Adresse x um eins */
*x = *x + 1;
}

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

return 0;
}
</pre>

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 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:
<pre>
void erhoehe (int x[])
{
x[0] = x[0] + 1;
x[1] = x[1] + 3;
x[2] = x[2] + 5;
}

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

erhoehe (a);
/* a hat jetzt folgenden Inhalt: 11, 23, 35 */

return 0;
}
</pre>

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

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

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

erhoehe (a);

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

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

=Besondere Datentypen=

==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, brauchen 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.

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

<pre>
#include <stdio.h>

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

int main (void)
{
int zahl;

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

return 0;
}
</pre>

==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: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <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!

'''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://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

2006-04-30T18:58:28Z

Johannuhrmann: /* Parameterübergabe */

Ein kurzer Einblick in die Programmiersprache C
=Allgemeines=
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 Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.

C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu 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.
<pre>
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

/* Anweisungen */
return 0;
}
</pre>

Die Beschreibung (die Erklärungen folgen):

;<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ücksichtige, 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 Unterprogramm main=
Unterprogramme lernen Sie zwar erst später kennen, aber dieses eine muß sein. In Gegensatz zu anderen Programmiersprachen gibt es in C kein "Hauptprogramm", sondern nur Unterprogramme. Aber woher soll der Computer wissen, welches Unterprogramm er am Beginn ausführen soll? Ganz einfach, er führt immer das Unterprogramm "main" aus. Dieses ist sozusagen 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 Integer Wert als Ergebnis zurückgeliefert. Beim [[Microcontroller]] ist main das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es dann also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß main oft als oft auch als void (Parameterfrei) definiert wird, wie oben im Beispiel zu erkennen. 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.
<pre>
/* void Definition von main ist nur beim Controller üblich
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main
* kein Fehler/Warnung erzeugt wird.
*/
void main(void)
{
}
</pre>
Was das bedeutet, lernen Sie in einem späteren Kapitel. Wichtig ist nur: ohne main ist kein Programm komplett, es lässt sich dann auch nicht ausführen!

=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":

<pre>
void main(void)
{ //der Block "main" beginnt
int Zahl;

{ //ein "namenloser" Block beginnt
//hier stehen Anweisungen
} //der "namenlose" Block endet
} //der Block "main" endet
</pre>

'''Bemerkung:'''
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, und welcher Art diese Daten sind. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können Sie alle möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können).

;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 ab!

===int, char, short, long (ganze Zahlen)===
In Variable dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, -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 recht 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>

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

=== 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 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: In Zukunft werden ich oft 1 als Synonym für "ungleich 0" verwenden. Bitte beachten Sie jedoch, das eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

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

==Zusammengesetzte Datentypen==
===Felder===
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 Felder, sogenannte ''Arrays'', zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits bekanntes Beispiel für ein Array ist ein String. Ein String ist nichts anderes als ein Array des Datentypes char.

'''Syntax:''' Datentyp Variablenname[Anzahl]

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

int main(void)
{
int Zaehler;
int Zahlen[10]; //Zahlen[0] bis Zahlen[9] !!!

for (Zaehler=0; Zaehler<10; Zaehler++)
{
printf ("Bitte Zahl %d eingeben: ", Zaehler);
scanf ("%d", & Zahlen[Zaehler]);
printf ("\n");
}
printf ("Super!\n");
for (Zaehler=0; Zaehler<10; Zaehler++)
printf ("Zahl %d war: %d\n", Zaehler, Zahlen[Zaehler]);
</pre>

'''Bemerkungen:'''
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.

{{FarbigerRahmen|
'''Merke:'''
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!
}}

===Mehrdimensionale Felder===
Manchmal benötigen 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.

==Strings (Zeichenketten)==
Bei einem String handelt es sich um ein Array, das aus einzelnen Zeichen 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.

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

<pre>
struct Person {
char vname[20], nname[20];
char telnr[15];
int alter;
};
</pre>

'''Erklärung:'''
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden 4 Variablen angelege: 3 Strings und ein <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach
struct Person Variablenname;
an.

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:
<pre>
struct Person hubert;

hubert.alter = 32;
</pre>

==Zeiger==
Jede Variable steht an einer genau definierten stelle im Speicher. Diese Stelle kann man in erfahrung bringen. Wie man das macht und was das überhaupt für Vorteile bringt, erfahren Sie in diesem Abschnitt.
Ein Zeiger ist im Prinzip eine (int-) Variable. In ihr ist jedoch keine Zahl gespeichert, sondern eine "Adresse". Diese gibt eine bestimmte Position im Arbeitsspeicher dar. Hier sehen Sie, wie man einen Zeiger definiert und mit ihm arbeitet:

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

void main(void)
{
int Zahl;
int *Zeiger;

Zeiger=&Zahl;
*Zeiger=12;

printf("%d = %d", Zahl, *Zeiger);
</pre>

'''Erklärung:'''
Um einen Zeiger anzulegen, gibt man folgendes an: Datentyp, dann einen Stern (*), anschließend den Namen (und einen Strichpunkt).
Um einen Zeiger auf eine bestimmte Zahl "zeigen" zu lassen, muß man dem Zeiger die Adresse einer Variablen zuordnen. Das funktioniert mittels dem Adress-Operator & (Zeiger=&Zahl).
Jetzt möchten Sie dem Zeiger einen Wert zuweisen. Aber natürlich nicht dem Zeiger, sondern der Variablen, auf die der Zeiger "zeigt". Na, "Zahl=Wert;", werden Sie sagen. Aber wozu dann Zeiger? Na, ja, jednefalls geht das mittels des "Inhalts-Operators" * (*Zeiger=12).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an printf (und jedes andere Unterprogramm) übergeben.

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

Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.
==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!
<pre>
int Zahl1, Zahl2;
char Zeichen;

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

return 0;
}
</pre>
;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 Zahl1 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 int und char dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable FALSE, ansonsten ist Sie TRUE.
intVariable = !0; // entspricht TRUE
intVariable = 0; // entspricht FALSE

==Vergleich von Variablen==
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln:
<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>
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl.
intVariable = Zahl1 <= Zahl2;
das komplette Beispiel zeigt es deutlicher:
<pre>
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */

printf ("Ergebnis: %d\n", i);
</pre>
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").

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

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

==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>: 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.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert.
Eine Variable ist so ein LValue, der etwas zugewiesen werden kann:
a = 1;
Hingegen ist <tt>a+1</tt> kein LValue, denn eine Zuweisung wie
a+1 = 2;
erzeugt einen Compilerfehler, der etwas lautet könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

==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 Eigenheit der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet.

Beispiel:
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */

<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,
die eine aufwändige Operation durchführt.
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.

Wo ist also der Unterschied? 
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.

==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:
<pre>
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */

/* z ist ein Zeiger auf eine Integervariable und enthält somit
die Speicheradresse einer Integervariablen
*/
int *z;

/* Verwendung des Adressoperators... */
z = &x; /* weise z die Speicheradresse von x zu */

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

/* da z auf x zeigt, hat auch x jetzt den Wert 6 */
</pre>

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

Statt
(*strukturZeiger).element
kann geschrieben werden
strukturZeiger->element
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

{{FarbigerRahmen |
'''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:

<pre>
int *z; /* z ist ein Zeiger auf einen Integer */

/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.
z enthält irgendeine(!) Adresse
*/

/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */
*z = *z + 1;
</pre>

Viele C-Compiler (z.B. gcc) 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'' durch, sondern unterdrückt nur die Compilerwarnungen oder
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in
eine Zahl oder umgekehrt zu wandeln:

<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 Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.
}}

==Komma Operator==
Mit einem <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.

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingte Zuweisung===
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;

==Blöcke==
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks.
Der Block muss un runden Klammern stehen:
int sum;
sum = ({
int i, s = 0;
for (i=1; i<= 100; i++)
s += i;
s;
});

Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc,
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer
Instruktion nicht machbar wäre:
<pre>
#define PSTR(s) \
({ \
static char __c[] PROGMEM = (s); \
__c; \
})
</pre>

==Reihenfolge der Auswertung==

=Kontrollanweisungen=

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

b1= b2 && b3;

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

b1= b2 || b3;

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

b1= !b2;

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

==<tt>if</tt>-Anweisung==
Syntax: IF (Bedingung) Anweisung;
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:

[[bild:ifthenelse.png]]

Und in C schreibt man:
<pre>
if (Bedingung) // WENN
{ // DANN
Anweisung1;
}
else
{ // SONST
Anweisung2;
}
</pre>
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.

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

<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki>

<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki>

Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.
}}

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

===<tt>while</tt>-Schleife===
'''Syntax:''' while (Bedingung) { Anweisung; }

Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block!

<pre>
Zahl1=0;
while (Zahl1<3)
{
Zahl1=Zahl1+1;
Zahl2=Zahl2*2;
}
</pre>

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.
===<tt>do</tt>-<tt>while</tt>-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. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird

<pre>
unsigned char bData;
do {
bData = getch(); // Tastatureingabe (s.u.)
}while (bData != 13);
</pre>

Die Schleife wird durchlaufen und wiederholt, solange etwas anderes als 13 (<ENTER>) eingegeben wird.

===<tt>for</tt>-Schleife===
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }

Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Hat sie einen bestimmten Wert erreicht, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block

Die gesammte Schleife wird solange durchgeführt, wie die Bedingung TRUE ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.

Die Theorie ist schwer, die Praxis nicht so sehr...

<pre>
int Zaehler;
for (Zaehler = 1; Zaehler <= 10; Zaehler++)
{
Zahl2 = Zahl2 + Zaehler;
}
</pre>
Das Äquivalent als "WHILE"
<pre>
int Zaehler;
Zaehler = 1; // Anfangswerte
while (Zaehler <= 10) // Bedingung
{
Zahl2 = Zahl2 + Zaehler;
Zaehler++; // Inkrement
}
</pre>

In diesem Beispiel wird Zahl2 in jedem Schleifendurchlauf um die Zählvariable Zaehler erhöht. Da Zaehler nacheinander die Werte von 1 bis 10 hat, ist in Zahl2 nach der Schleife die Summe der Zahlen 1 bis 10 gespeichert.

'''Erklärung:'''
Zaehler=1 bedeutet, dass der Variablen Zaehler vor dem 1. Schleifendurchlauf der Wert 1 zugewiesen wird.
Zaehler<=10 ist die Schleifenbedingung; ist sie FALSE, wird die Schleife beendet.
Zaehler++ bedeutet, dass Zaehler nach jedem Durchlauf um 1 erhöht wird.

=Ein- und Ausgabe=

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

Der dazu notwendige Befehl ist printf (das f ist KEIN Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf dem Bildschirm aus (außer, Sie haben unter DOS die Standard-Ausgabe auf ein anderes Gerät, z.B. den Drucker umgeleitet, aber das ist eine andere Geschichte). Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. int, char, float, double) sein!
<pre>
#include <conio.h>
#include <stdio.h>

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

Hinweis:
Dass das Programm nach dem Compilieren und Ausführen sofort wieder beendet wird, ist nicht Ihr Fehler. Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!
Erklärung:

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

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

In der 3. Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet %c "char" (Zeichen). Es wird also %c durch 'A' ersetzt.

Die letzte Ausgabe verhält sich merkwürdig es wird doch tatsächlich eine Zahl ausgegeben, obwohl der Parameter ein Zeichen (char) ist. Aber:
%d im Text bedeutet, dass eine Zahl auszugeben ist.
ein char kann ja auch als Zahl interpretiert werden.
Es wird also 65 (der ASCII-Wert von 'A') ausgegeben. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer char Variablen!

'''Bildschirm löschen'''

Oft sind von anderen Programmen noch "Rückstände" vorhanden. Nicht nur um die zu beseitigen, brauchen Sie einen "Bildschirm-Lösch-Befehl". Dieser ist in conio.h definiert und nennt sich "clrscr" ("clear screen", deut: "lösche Bildschirm").
<pre>
#include <conio.h>
#include <stdio.h>

void main(void)
{
clrscr();
...
}
</pre>

==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.
Der wichtigste Befehl ist "scanf". Er liest Daten von der Tastatur. Die Syntax entspricht derer von printf, nur daß man außer den %c und %d keine weiteren Angaben im "Text" machen darf:

<pre>
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. Diese Zahl wird in Zahl1 abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

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

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

===getch===
getch ist eine Funktion (Siehe Kapitel Unterprogramme), die ein char-Zeichen von der Tastatur einliest. Dazu geben Sie im Programm einfach folgende Zeile an:

<pre>
char zeichen;
zeichen = getch();
</pre>
Diese Zeile erwartet die Eingabe eines char-Zeichens. Im Gegensatz zu scanf muß man nach der Eingabe des Zeichens jedoch nicht [ENTER] drücken, um die Eingabe zu bestätigen. In der Variable zeichen wird das erste Zeichen gespeichert, das auf der Tastatur eingegeben wird.

Eine weiter Möglichkeit der Anwendung von getch ist es, wenn Sie einfach "getch();" als Befehl eingeben. Dann wartet der Computer, bis Sie eine Taste drücken, speichert diese aber nicht ab.

===kbhit===
Dies ist ebenfalls eine Funktion, die eine boolschen Ausdruck zurück liefert. Sie gibt Bescheid darüber, ob eine Taste gedrückt wurde, und mit scanf oder getch abgerufen werden kann (zum Verständnis: auf der Tastatur eingegebene Zeichen werden meist nicht direkt vom Programm verarbeitet, sondern erst vom Betriebssystem bzw. dem BIOS des Computers gespeichert. Wenn das Programm nun eine Eingabe erwartet, werden die gespeicherten Zeichen "verwendet". Dies lauft jedoch so schnell ab, daß der Benutzer davon nichts merkt). Ist diese Variable TRUE, dann ist ein Zeichen abfragebereit, sonst nicht:

<pre>
while ( !kbhit() )
{
Zahl1=Zahl1+1;
printf("%d\n",Zahl1);
}
</pre>

Dieser Programmteil erhöht solange Zahl1 und gibt diese aus, bis der Benutzer eine Taste drückt.

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

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

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

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

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

void main(void)
{
int zahl1,ergebnis;

printf("Bitte Zahl eingeben: ");
scanf("%d",&zahl1);
ergebnis = hoch2(zahl1);
printf("%d hoch 2 = %d\n",zahl1,ergebnis);
printf("5 hoch 2 = %d\n",hoch2(5));
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen.
Geschachtelte-Unterprogramme wie z.B. in Pascal sind nicht möglich.
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Bei z.B. getch() ist das char. Danach folgt der Name der Funktion (case-sensitiv!). Danach kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden, und mittels Beistrich voneinander getrennt werden. Am Ende ist kein Beistrich!
Im Block der Funktion können alle Anweisungen ausgeführt werden und Variablen deklariert werden.
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung "return" und dem Rückgabewert.
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an "Variable=Funktion(Parameter);". Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

==Prozedur==
'''Syntax:''' void Name(Parameterliste);

Eine Prozedur ist nichts anderes als eine Funktion ohne Rückgabewert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede:

Als Rückgabe-Datentyp wird void angegeben.
Eine Prozedur kann daher beim Aufruf nicht einer Variablen zugewiesen werden (wie FUNCTION's) sonder wird wie eine normale Anweisung behandelt (wie z.B. printf).

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

void ausgeben(int Param1);
{
printf("Der Wert der Variablen beträgt: %d\n",Param1);
}

void main(void)
{
int Zahl1;
ausgeben(23);
Zahl1=4;
ausgeben(Zahl1);
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Durch den Befehl "ausgeben(23)" wird die Prozedur "ausgeben" mit dem Parameter 23 aufgerufen. Param1 hat also den Wert 23. Die einzige Anweisung innerhalb der Prozedur ist printf, was nun ausgeführt wird.
Danach wird mit dem nächsten Befehl innerhalb des Hauptprogrammes fortgefahren ("Zahl1=4").
Der 2. Aufruf von ausgeben erfolgt mit dem Parameter Zahl1, also wird Param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels printf ausgeben.
Unterprogramme ohne Parameter
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, z.B. main, haben statt der Parameter immer nur void stehen. Was bedeutet das? Nun ja, C erwartet, das Sie die Parameter angeben. void bedeutet "es gibt keine Parameter". "void main(void)" bedeutet also: "Erstelle ein Unterprogramm Namens main, das keinen Rückgabewert und keine Parameter hat".

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, z.B. getch, müssen Sie beim Aufruf trotzdem die Klammern angeben. Der Befehl "getch;" führt nicht getch ohne Parameter aus, sondern liefert die Adresse der Funktion getch. Alles klar? Na ja, jedenfalls: Beim Aufruf jedes Unterpgrogrammes immmer Klammern angeben.
}}

==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 1. Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Definition davor erledigt haben. Verstanden?
Um dies zu erreichen, gibt es zwei Möglichkeiten:

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

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

void ausgeben(int Zahl); //Der Prototyp

void main(void)
{
clrscr();
ausgeben(12);
getch();
}

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 [[C-Tutorial#Zeiger | Zeiger]] übergeben werden.
# Werden [[C-Tutorial#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:
<pre>
void erhoehe(int x)
{
x = x + 1;
}

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

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 x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.

<pre>
void erhoehe(int *x)
{
/* erhöhe den Wert an der Adresse x um eins */
*x = *x + 1;
}

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

Jetzt wird im Hauptprogramm mittels [[C-Tutorial#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 Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[C-Tutorial#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:
<pre>
void erhoehe(int x[])
{
x[0] = x[0] + 1;
x[1] = x[1] + 3;
x[2] = x[2] + 5;
}

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

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

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

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

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

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

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

=Besondere Datentypen=

==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 <conio.h>
#include <stdio.h>
#include <string.h>

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

strcpy(stri1,"hallo");
clrscr();
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);
getch();
}
</pre>

'''Hinweis:'''
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, brauchen Sie kein & bei scanf angeben!

'''Erklärung:'''
Es werden 2 gleich große Strings definiert: stri1 und eingabe, mit je 20 "nutzbaren" Zeichen.
stri1 wird der Wert "hallo" zugewiesen. Das 0-Zeichen wird automatisch angefügt!
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt %s ins Spiel. Es hat die gleiche Aufgabe wie %d oder %c, nur halt für Strings.
Sie werden gebeten, eine String einzugeben.
Dieser String wird danach in die Variable stri1 kopiert.
Beide Strings (die ja nun auch den selben Wert haben) werden ausgegeben.

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

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

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

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

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

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

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

void main(void)
{
int Zahl;
printf("Zahl eingeben: ");
scanf("%d",&Zahl);
erhoehe(&Zahl);
printf("\nDie erhoehte Zahl lautet: %d\n",Zahl);
getch();
}
</pre>

==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: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
void 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>

void 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!

'''Autoren'''
* Plasma
* Bernd

'''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://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

2006-04-30T18:30:22Z

Johannuhrmann: /* Index-Operator bei Arrays */

Ein kurzer Einblick in die Programmiersprache C
=Allgemeines=
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 Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.

C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu 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.
<pre>
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

/* Anweisungen */
return 0;
}
</pre>

Die Beschreibung (die Erklärungen folgen):

;<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ücksichtige, 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 Unterprogramm main=
Unterprogramme lernen Sie zwar erst später kennen, aber dieses eine muß sein. In Gegensatz zu anderen Programmiersprachen gibt es in C kein "Hauptprogramm", sondern nur Unterprogramme. Aber woher soll der Computer wissen, welches Unterprogramm er am Beginn ausführen soll? Ganz einfach, er führt immer das Unterprogramm "main" aus. Dieses ist sozusagen 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 Integer Wert als Ergebnis zurückgeliefert. Beim [[Microcontroller]] ist main das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es dann also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß main oft als oft auch als void (Parameterfrei) definiert wird, wie oben im Beispiel zu erkennen. 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.
<pre>
/* void Definition von main ist nur beim Controller üblich
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main
* kein Fehler/Warnung erzeugt wird.
*/
void main(void)
{
}
</pre>
Was das bedeutet, lernen Sie in einem späteren Kapitel. Wichtig ist nur: ohne main ist kein Programm komplett, es lässt sich dann auch nicht ausführen!

=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":

<pre>
void main(void)
{ //der Block "main" beginnt
int Zahl;

{ //ein "namenloser" Block beginnt
//hier stehen Anweisungen
} //der "namenlose" Block endet
} //der Block "main" endet
</pre>

'''Bemerkung:'''
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, und welcher Art diese Daten sind. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können Sie alle möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können).

;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 ab!

===int, char, short, long (ganze Zahlen)===
In Variable dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, -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 recht 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>

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

=== 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 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: In Zukunft werden ich oft 1 als Synonym für "ungleich 0" verwenden. Bitte beachten Sie jedoch, das eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

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

==Zusammengesetzte Datentypen==
===Felder===
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 Felder, sogenannte ''Arrays'', zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits bekanntes Beispiel für ein Array ist ein String. Ein String ist nichts anderes als ein Array des Datentypes char.

'''Syntax:''' Datentyp Variablenname[Anzahl]

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

int main(void)
{
int Zaehler;
int Zahlen[10]; //Zahlen[0] bis Zahlen[9] !!!

for (Zaehler=0; Zaehler<10; Zaehler++)
{
printf ("Bitte Zahl %d eingeben: ", Zaehler);
scanf ("%d", & Zahlen[Zaehler]);
printf ("\n");
}
printf ("Super!\n");
for (Zaehler=0; Zaehler<10; Zaehler++)
printf ("Zahl %d war: %d\n", Zaehler, Zahlen[Zaehler]);
</pre>

'''Bemerkungen:'''
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.

{{FarbigerRahmen|
'''Merke:'''
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!
}}

===Mehrdimensionale Felder===
Manchmal benötigen 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.

==Strings (Zeichenketten)==
Bei einem String handelt es sich um ein Array, das aus einzelnen Zeichen 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.

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

<pre>
struct Person {
char vname[20], nname[20];
char telnr[15];
int alter;
};
</pre>

'''Erklärung:'''
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden 4 Variablen angelege: 3 Strings und ein <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach
struct Person Variablenname;
an.

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:
<pre>
struct Person hubert;

hubert.alter = 32;
</pre>

==Zeiger==
Jede Variable steht an einer genau definierten stelle im Speicher. Diese Stelle kann man in erfahrung bringen. Wie man das macht und was das überhaupt für Vorteile bringt, erfahren Sie in diesem Abschnitt.
Ein Zeiger ist im Prinzip eine (int-) Variable. In ihr ist jedoch keine Zahl gespeichert, sondern eine "Adresse". Diese gibt eine bestimmte Position im Arbeitsspeicher dar. Hier sehen Sie, wie man einen Zeiger definiert und mit ihm arbeitet:

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

void main(void)
{
int Zahl;
int *Zeiger;

Zeiger=&Zahl;
*Zeiger=12;

printf("%d = %d", Zahl, *Zeiger);
</pre>

'''Erklärung:'''
Um einen Zeiger anzulegen, gibt man folgendes an: Datentyp, dann einen Stern (*), anschließend den Namen (und einen Strichpunkt).
Um einen Zeiger auf eine bestimmte Zahl "zeigen" zu lassen, muß man dem Zeiger die Adresse einer Variablen zuordnen. Das funktioniert mittels dem Adress-Operator & (Zeiger=&Zahl).
Jetzt möchten Sie dem Zeiger einen Wert zuweisen. Aber natürlich nicht dem Zeiger, sondern der Variablen, auf die der Zeiger "zeigt". Na, "Zahl=Wert;", werden Sie sagen. Aber wozu dann Zeiger? Na, ja, jednefalls geht das mittels des "Inhalts-Operators" * (*Zeiger=12).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an printf (und jedes andere Unterprogramm) übergeben.

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

Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.
==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!
<pre>
int Zahl1, Zahl2;
char Zeichen;

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

return 0;
}
</pre>
;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 Zahl1 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 int und char dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable FALSE, ansonsten ist Sie TRUE.
intVariable = !0; // entspricht TRUE
intVariable = 0; // entspricht FALSE

==Vergleich von Variablen==
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln:
<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>
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl.
intVariable = Zahl1 <= Zahl2;
das komplette Beispiel zeigt es deutlicher:
<pre>
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */

printf ("Ergebnis: %d\n", i);
</pre>
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").

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

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

==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>: 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.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert.
Eine Variable ist so ein LValue, der etwas zugewiesen werden kann:
a = 1;
Hingegen ist <tt>a+1</tt> kein LValue, denn eine Zuweisung wie
a+1 = 2;
erzeugt einen Compilerfehler, der etwas lautet könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

==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 Eigenheit der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet.

Beispiel:
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */

<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,
die eine aufwändige Operation durchführt.
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.

Wo ist also der Unterschied? 
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.

==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:
<pre>
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */

/* z ist ein Zeiger auf eine Integervariable und enthält somit
die Speicheradresse einer Integervariablen
*/
int *z;

/* Verwendung des Adressoperators... */
z = &x; /* weise z die Speicheradresse von x zu */

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

/* da z auf x zeigt, hat auch x jetzt den Wert 6 */
</pre>

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

Statt
(*strukturZeiger).element
kann geschrieben werden
strukturZeiger->element
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

{{FarbigerRahmen |
'''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:

<pre>
int *z; /* z ist ein Zeiger auf einen Integer */

/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.
z enthält irgendeine(!) Adresse
*/

/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */
*z = *z + 1;
</pre>

Viele C-Compiler (z.B. gcc) 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'' durch, sondern unterdrückt nur die Compilerwarnungen oder
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in
eine Zahl oder umgekehrt zu wandeln:

<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 Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.
}}

==Komma Operator==
Mit einem <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.

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingte Zuweisung===
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;

==Blöcke==
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks.
Der Block muss un runden Klammern stehen:
int sum;
sum = ({
int i, s = 0;
for (i=1; i<= 100; i++)
s += i;
s;
});

Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc,
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer
Instruktion nicht machbar wäre:
<pre>
#define PSTR(s) \
({ \
static char __c[] PROGMEM = (s); \
__c; \
})
</pre>

==Reihenfolge der Auswertung==

=Kontrollanweisungen=

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

b1= b2 && b3;

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

b1= b2 || b3;

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

b1= !b2;

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

==<tt>if</tt>-Anweisung==
Syntax: IF (Bedingung) Anweisung;
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:

[[bild:ifthenelse.png]]

Und in C schreibt man:
<pre>
if (Bedingung) // WENN
{ // DANN
Anweisung1;
}
else
{ // SONST
Anweisung2;
}
</pre>
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.

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

<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki>

<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki>

Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.
}}

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

===<tt>while</tt>-Schleife===
'''Syntax:''' while (Bedingung) { Anweisung; }

Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block!

<pre>
Zahl1=0;
while (Zahl1<3)
{
Zahl1=Zahl1+1;
Zahl2=Zahl2*2;
}
</pre>

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.
===<tt>do</tt>-<tt>while</tt>-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. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird

<pre>
unsigned char bData;
do {
bData = getch(); // Tastatureingabe (s.u.)
}while (bData != 13);
</pre>

Die Schleife wird durchlaufen und wiederholt, solange etwas anderes als 13 (<ENTER>) eingegeben wird.

===<tt>for</tt>-Schleife===
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }

Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Hat sie einen bestimmten Wert erreicht, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block

Die gesammte Schleife wird solange durchgeführt, wie die Bedingung TRUE ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.

Die Theorie ist schwer, die Praxis nicht so sehr...

<pre>
int Zaehler;
for (Zaehler = 1; Zaehler <= 10; Zaehler++)
{
Zahl2 = Zahl2 + Zaehler;
}
</pre>
Das Äquivalent als "WHILE"
<pre>
int Zaehler;
Zaehler = 1; // Anfangswerte
while (Zaehler <= 10) // Bedingung
{
Zahl2 = Zahl2 + Zaehler;
Zaehler++; // Inkrement
}
</pre>

In diesem Beispiel wird Zahl2 in jedem Schleifendurchlauf um die Zählvariable Zaehler erhöht. Da Zaehler nacheinander die Werte von 1 bis 10 hat, ist in Zahl2 nach der Schleife die Summe der Zahlen 1 bis 10 gespeichert.

'''Erklärung:'''
Zaehler=1 bedeutet, dass der Variablen Zaehler vor dem 1. Schleifendurchlauf der Wert 1 zugewiesen wird.
Zaehler<=10 ist die Schleifenbedingung; ist sie FALSE, wird die Schleife beendet.
Zaehler++ bedeutet, dass Zaehler nach jedem Durchlauf um 1 erhöht wird.

=Ein- und Ausgabe=

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

Der dazu notwendige Befehl ist printf (das f ist KEIN Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf dem Bildschirm aus (außer, Sie haben unter DOS die Standard-Ausgabe auf ein anderes Gerät, z.B. den Drucker umgeleitet, aber das ist eine andere Geschichte). Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. int, char, float, double) sein!
<pre>
#include <conio.h>
#include <stdio.h>

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

Hinweis:
Dass das Programm nach dem Compilieren und Ausführen sofort wieder beendet wird, ist nicht Ihr Fehler. Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!
Erklärung:

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

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

In der 3. Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet %c "char" (Zeichen). Es wird also %c durch 'A' ersetzt.

Die letzte Ausgabe verhält sich merkwürdig es wird doch tatsächlich eine Zahl ausgegeben, obwohl der Parameter ein Zeichen (char) ist. Aber:
%d im Text bedeutet, dass eine Zahl auszugeben ist.
ein char kann ja auch als Zahl interpretiert werden.
Es wird also 65 (der ASCII-Wert von 'A') ausgegeben. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer char Variablen!

'''Bildschirm löschen'''

Oft sind von anderen Programmen noch "Rückstände" vorhanden. Nicht nur um die zu beseitigen, brauchen Sie einen "Bildschirm-Lösch-Befehl". Dieser ist in conio.h definiert und nennt sich "clrscr" ("clear screen", deut: "lösche Bildschirm").
<pre>
#include <conio.h>
#include <stdio.h>

void main(void)
{
clrscr();
...
}
</pre>

==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.
Der wichtigste Befehl ist "scanf". Er liest Daten von der Tastatur. Die Syntax entspricht derer von printf, nur daß man außer den %c und %d keine weiteren Angaben im "Text" machen darf:

<pre>
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. Diese Zahl wird in Zahl1 abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

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

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

===getch===
getch ist eine Funktion (Siehe Kapitel Unterprogramme), die ein char-Zeichen von der Tastatur einliest. Dazu geben Sie im Programm einfach folgende Zeile an:

<pre>
char zeichen;
zeichen = getch();
</pre>
Diese Zeile erwartet die Eingabe eines char-Zeichens. Im Gegensatz zu scanf muß man nach der Eingabe des Zeichens jedoch nicht [ENTER] drücken, um die Eingabe zu bestätigen. In der Variable zeichen wird das erste Zeichen gespeichert, das auf der Tastatur eingegeben wird.

Eine weiter Möglichkeit der Anwendung von getch ist es, wenn Sie einfach "getch();" als Befehl eingeben. Dann wartet der Computer, bis Sie eine Taste drücken, speichert diese aber nicht ab.

===kbhit===
Dies ist ebenfalls eine Funktion, die eine boolschen Ausdruck zurück liefert. Sie gibt Bescheid darüber, ob eine Taste gedrückt wurde, und mit scanf oder getch abgerufen werden kann (zum Verständnis: auf der Tastatur eingegebene Zeichen werden meist nicht direkt vom Programm verarbeitet, sondern erst vom Betriebssystem bzw. dem BIOS des Computers gespeichert. Wenn das Programm nun eine Eingabe erwartet, werden die gespeicherten Zeichen "verwendet". Dies lauft jedoch so schnell ab, daß der Benutzer davon nichts merkt). Ist diese Variable TRUE, dann ist ein Zeichen abfragebereit, sonst nicht:

<pre>
while ( !kbhit() )
{
Zahl1=Zahl1+1;
printf("%d\n",Zahl1);
}
</pre>

Dieser Programmteil erhöht solange Zahl1 und gibt diese aus, bis der Benutzer eine Taste drückt.

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

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

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

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

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

void main(void)
{
int zahl1,ergebnis;

printf("Bitte Zahl eingeben: ");
scanf("%d",&zahl1);
ergebnis = hoch2(zahl1);
printf("%d hoch 2 = %d\n",zahl1,ergebnis);
printf("5 hoch 2 = %d\n",hoch2(5));
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen.
Geschachtelte-Unterprogramme wie z.B. in Pascal sind nicht möglich.
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Bei z.B. getch() ist das char. Danach folgt der Name der Funktion (case-sensitiv!). Danach kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden, und mittels Beistrich voneinander getrennt werden. Am Ende ist kein Beistrich!
Im Block der Funktion können alle Anweisungen ausgeführt werden und Variablen deklariert werden.
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung "return" und dem Rückgabewert.
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an "Variable=Funktion(Parameter);". Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

==Prozedur==
'''Syntax:''' void Name(Parameterliste);

Eine Prozedur ist nichts anderes als eine Funktion ohne Rückgabewert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede:

Als Rückgabe-Datentyp wird void angegeben.
Eine Prozedur kann daher beim Aufruf nicht einer Variablen zugewiesen werden (wie FUNCTION's) sonder wird wie eine normale Anweisung behandelt (wie z.B. printf).

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

void ausgeben(int Param1);
{
printf("Der Wert der Variablen beträgt: %d\n",Param1);
}

void main(void)
{
int Zahl1;
ausgeben(23);
Zahl1=4;
ausgeben(Zahl1);
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Durch den Befehl "ausgeben(23)" wird die Prozedur "ausgeben" mit dem Parameter 23 aufgerufen. Param1 hat also den Wert 23. Die einzige Anweisung innerhalb der Prozedur ist printf, was nun ausgeführt wird.
Danach wird mit dem nächsten Befehl innerhalb des Hauptprogrammes fortgefahren ("Zahl1=4").
Der 2. Aufruf von ausgeben erfolgt mit dem Parameter Zahl1, also wird Param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels printf ausgeben.
Unterprogramme ohne Parameter
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, z.B. main, haben statt der Parameter immer nur void stehen. Was bedeutet das? Nun ja, C erwartet, das Sie die Parameter angeben. void bedeutet "es gibt keine Parameter". "void main(void)" bedeutet also: "Erstelle ein Unterprogramm Namens main, das keinen Rückgabewert und keine Parameter hat".

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, z.B. getch, müssen Sie beim Aufruf trotzdem die Klammern angeben. Der Befehl "getch;" führt nicht getch ohne Parameter aus, sondern liefert die Adresse der Funktion getch. Alles klar? Na ja, jedenfalls: Beim Aufruf jedes Unterpgrogrammes immmer Klammern angeben.
}}

==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 1. Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Definition davor erledigt haben. Verstanden?
Um dies zu erreichen, gibt es zwei Möglichkeiten:

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

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

void ausgeben(int Zahl); //Der Prototyp

void main(void)
{
clrscr();
ausgeben(12);
getch();
}

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 [[C-Tutorial#Zeiger | Zeiger]] übergeben werden.
# Werden [[C-Tutorial#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:
<pre>
void erhoehe(int x)
{
x = x + 1;
}

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

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 x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.

<pre>
void erhoehe(int *x)
{
/* erhöhe den Wert an der Adresse x um eins */
*x = *x + 1;
}

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

Jetzt wird im Hauptprogramm mittels [[C-Tutorial#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 Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.

=Besondere Datentypen=

==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 <conio.h>
#include <stdio.h>
#include <string.h>

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

strcpy(stri1,"hallo");
clrscr();
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);
getch();
}
</pre>

'''Hinweis:'''
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, brauchen Sie kein & bei scanf angeben!

'''Erklärung:'''
Es werden 2 gleich große Strings definiert: stri1 und eingabe, mit je 20 "nutzbaren" Zeichen.
stri1 wird der Wert "hallo" zugewiesen. Das 0-Zeichen wird automatisch angefügt!
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt %s ins Spiel. Es hat die gleiche Aufgabe wie %d oder %c, nur halt für Strings.
Sie werden gebeten, eine String einzugeben.
Dieser String wird danach in die Variable stri1 kopiert.
Beide Strings (die ja nun auch den selben Wert haben) werden ausgegeben.

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

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

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

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

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

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

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

void main(void)
{
int Zahl;
printf("Zahl eingeben: ");
scanf("%d",&Zahl);
erhoehe(&Zahl);
printf("\nDie erhoehte Zahl lautet: %d\n",Zahl);
getch();
}
</pre>

==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: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
void 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>

void 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!

'''Autoren'''
* Plasma
* Bernd

'''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://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

2006-04-30T09:22:36Z

Johannuhrmann: /* Cast-Operator */

Ein kurzer Einblick in die Programmiersprache C
=Allgemeines=
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 Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.

C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu 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.
<pre>
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

/* Anweisungen */
return 0;
}
</pre>

Die Beschreibung (die Erklärungen folgen):

;<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ücksichtige, 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 Unterprogramm main=
Unterprogramme lernen Sie zwar erst später kennen, aber dieses eine muß sein. In Gegensatz zu anderen Programmiersprachen gibt es in C kein "Hauptprogramm", sondern nur Unterprogramme. Aber woher soll der Computer wissen, welches Unterprogramm er am Beginn ausführen soll? Ganz einfach, er führt immer das Unterprogramm "main" aus. Dieses ist sozusagen 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 Integer Wert als Ergebnis zurückgeliefert. Beim [[Microcontroller]] ist main das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es dann also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß main oft als oft auch als void (Parameterfrei) definiert wird, wie oben im Beispiel zu erkennen. 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.
<pre>
/* void Definition von main ist nur beim Controller üblich
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main
* kein Fehler/Warnung erzeugt wird.
*/
void main(void)
{
}
</pre>
Was das bedeutet, lernen Sie in einem späteren Kapitel. Wichtig ist nur: ohne main ist kein Programm komplett, es lässt sich dann auch nicht ausführen!

=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":

<pre>
void main(void)
{ //der Block "main" beginnt
int Zahl;

{ //ein "namenloser" Block beginnt
//hier stehen Anweisungen
} //der "namenlose" Block endet
} //der Block "main" endet
</pre>

'''Bemerkung:'''
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, und welcher Art diese Daten sind. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können Sie alle möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können).

;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 ab!

===int, char, short, long (ganze Zahlen)===
In Variable dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, -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 recht 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>

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

=== 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 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: In Zukunft werden ich oft 1 als Synonym für "ungleich 0" verwenden. Bitte beachten Sie jedoch, das eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

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

==Zusammengesetzte Datentypen==
===Felder===
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 Felder, sogenannte ''Arrays'', zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits bekanntes Beispiel für ein Array ist ein String. Ein String ist nichts anderes als ein Array des Datentypes char.

'''Syntax:''' Datentyp Variablenname[Anzahl]

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

int main(void)
{
int Zaehler;
int Zahlen[10]; //Zahlen[0] bis Zahlen[9] !!!

for (Zaehler=0; Zaehler<10; Zaehler++)
{
printf ("Bitte Zahl %d eingeben: ", Zaehler);
scanf ("%d", & Zahlen[Zaehler]);
printf ("\n");
}
printf ("Super!\n");
for (Zaehler=0; Zaehler<10; Zaehler++)
printf ("Zahl %d war: %d\n", Zaehler, Zahlen[Zaehler]);
</pre>

'''Bemerkungen:'''
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.

{{FarbigerRahmen|
'''Merke:'''
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!
}}

===Mehrdimensionale Felder===
Manchmal benötigen 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.

==Strings (Zeichenketten)==
Bei einem String handelt es sich um ein Array, das aus einzelnen Zeichen 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.

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

<pre>
struct Person {
char vname[20], nname[20];
char telnr[15];
int alter;
};
</pre>

'''Erklärung:'''
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden 4 Variablen angelege: 3 Strings und ein <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach
struct Person Variablenname;
an.

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:
<pre>
struct Person hubert;

hubert.alter = 32;
</pre>

==Zeiger==
Jede Variable steht an einer genau definierten stelle im Speicher. Diese Stelle kann man in erfahrung bringen. Wie man das macht und was das überhaupt für Vorteile bringt, erfahren Sie in diesem Abschnitt.
Ein Zeiger ist im Prinzip eine (int-) Variable. In ihr ist jedoch keine Zahl gespeichert, sondern eine "Adresse". Diese gibt eine bestimmte Position im Arbeitsspeicher dar. Hier sehen Sie, wie man einen Zeiger definiert und mit ihm arbeitet:

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

void main(void)
{
int Zahl;
int *Zeiger;

Zeiger=&Zahl;
*Zeiger=12;

printf("%d = %d", Zahl, *Zeiger);
</pre>

'''Erklärung:'''
Um einen Zeiger anzulegen, gibt man folgendes an: Datentyp, dann einen Stern (*), anschließend den Namen (und einen Strichpunkt).
Um einen Zeiger auf eine bestimmte Zahl "zeigen" zu lassen, muß man dem Zeiger die Adresse einer Variablen zuordnen. Das funktioniert mittels dem Adress-Operator & (Zeiger=&Zahl).
Jetzt möchten Sie dem Zeiger einen Wert zuweisen. Aber natürlich nicht dem Zeiger, sondern der Variablen, auf die der Zeiger "zeigt". Na, "Zahl=Wert;", werden Sie sagen. Aber wozu dann Zeiger? Na, ja, jednefalls geht das mittels des "Inhalts-Operators" * (*Zeiger=12).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an printf (und jedes andere Unterprogramm) übergeben.

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

Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.
==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!
<pre>
int Zahl1, Zahl2;
char Zeichen;

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

return 0;
}
</pre>
;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 Zahl1 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 int und char dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable FALSE, ansonsten ist Sie TRUE.
intVariable = !0; // entspricht TRUE
intVariable = 0; // entspricht FALSE

==Vergleich von Variablen==
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln:
<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>
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl.
intVariable = Zahl1 <= Zahl2;
das komplette Beispiel zeigt es deutlicher:
<pre>
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */

printf ("Ergebnis: %d\n", i);
</pre>
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").

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

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

==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>: 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.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert.
Eine Variable ist so ein LValue, der etwas zugewiesen werden kann:
a = 1;
Hingegen ist <tt>a+1</tt> kein LValue, denn eine Zuweisung wie
a+1 = 2;
erzeugt einen Compilerfehler, der etwas lautet könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

==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 Eigenheit der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet.

Beispiel:
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */

<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,
die eine aufwändige Operation durchführt.
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.

Wo ist also der Unterschied? 
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.

==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==
==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:
<pre>
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */

/* z ist ein Zeiger auf eine Integervariable und enthält somit
die Speicheradresse einer Integervariablen
*/
int *z;

/* Verwendung des Adressoperators... */
z = &x; /* weise z die Speicheradresse von x zu */

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

/* da z auf x zeigt, hat auch x jetzt den Wert 6 */
</pre>

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

Statt
(*strukturZeiger).element
kann geschrieben werden
strukturZeiger->element
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

{{FarbigerRahmen |
'''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:

<pre>
int *z; /* z ist ein Zeiger auf einen Integer */

/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.
z enthält irgendeine(!) Adresse
*/

/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */
*z = *z + 1;
</pre>

Viele C-Compiler (z.B. gcc) 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'' durch, sondern unterdrückt nur die Compilerwarnungen oder
-fehler, die bei einer "verdächtigen" Umwandlung passieren. Er kann also nicht benutzt werden, um einen Text in
eine Zahl oder umgekehrt zu wandeln:

<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 Speicheradresse, an der der Text "5.6" beginnt. Der Cast-Operator
unterdrückt nur die Warnung, die auf den Fehler hinweisen will.
}}

==Komma Operator==
Mit einem <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.

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingte Zuweisung===
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;

==Blöcke==
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks.
Der Block muss un runden Klammern stehen:
int sum;
sum = ({
int i, s = 0;
for (i=1; i<= 100; i++)
s += i;
s;
});

Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc,
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer
Instruktion nicht machbar wäre:
<pre>
#define PSTR(s) \
({ \
static char __c[] PROGMEM = (s); \
__c; \
})
</pre>

==Reihenfolge der Auswertung==

=Kontrollanweisungen=

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

b1= b2 && b3;

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

b1= b2 || b3;

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

b1= !b2;

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

==<tt>if</tt>-Anweisung==
Syntax: IF (Bedingung) Anweisung;
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:

[[bild:ifthenelse.png]]

Und in C schreibt man:
<pre>
if (Bedingung) // WENN
{ // DANN
Anweisung1;
}
else
{ // SONST
Anweisung2;
}
</pre>
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.

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

<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki>

<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki>

Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.
}}

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

===<tt>while</tt>-Schleife===
'''Syntax:''' while (Bedingung) { Anweisung; }

Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block!

<pre>
Zahl1=0;
while (Zahl1<3)
{
Zahl1=Zahl1+1;
Zahl2=Zahl2*2;
}
</pre>

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.
===<tt>do</tt>-<tt>while</tt>-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. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird

<pre>
unsigned char bData;
do {
bData = getch(); // Tastatureingabe (s.u.)
}while (bData != 13);
</pre>

Die Schleife wird durchlaufen und wiederholt, solange etwas anderes als 13 (<ENTER>) eingegeben wird.

===<tt>for</tt>-Schleife===
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }

Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Hat sie einen bestimmten Wert erreicht, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block

Die gesammte Schleife wird solange durchgeführt, wie die Bedingung TRUE ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.

Die Theorie ist schwer, die Praxis nicht so sehr...

<pre>
int Zaehler;
for (Zaehler = 1; Zaehler <= 10; Zaehler++)
{
Zahl2 = Zahl2 + Zaehler;
}
</pre>
Das Äquivalent als "WHILE"
<pre>
int Zaehler;
Zaehler = 1; // Anfangswerte
while (Zaehler <= 10) // Bedingung
{
Zahl2 = Zahl2 + Zaehler;
Zaehler++; // Inkrement
}
</pre>

In diesem Beispiel wird Zahl2 in jedem Schleifendurchlauf um die Zählvariable Zaehler erhöht. Da Zaehler nacheinander die Werte von 1 bis 10 hat, ist in Zahl2 nach der Schleife die Summe der Zahlen 1 bis 10 gespeichert.

'''Erklärung:'''
Zaehler=1 bedeutet, dass der Variablen Zaehler vor dem 1. Schleifendurchlauf der Wert 1 zugewiesen wird.
Zaehler<=10 ist die Schleifenbedingung; ist sie FALSE, wird die Schleife beendet.
Zaehler++ bedeutet, dass Zaehler nach jedem Durchlauf um 1 erhöht wird.

=Ein- und Ausgabe=

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

Der dazu notwendige Befehl ist printf (das f ist KEIN Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf dem Bildschirm aus (außer, Sie haben unter DOS die Standard-Ausgabe auf ein anderes Gerät, z.B. den Drucker umgeleitet, aber das ist eine andere Geschichte). Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. int, char, float, double) sein!
<pre>
#include <conio.h>
#include <stdio.h>

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

Hinweis:
Dass das Programm nach dem Compilieren und Ausführen sofort wieder beendet wird, ist nicht Ihr Fehler. Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!
Erklärung:

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

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

In der 3. Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet %c "char" (Zeichen). Es wird also %c durch 'A' ersetzt.

Die letzte Ausgabe verhält sich merkwürdig es wird doch tatsächlich eine Zahl ausgegeben, obwohl der Parameter ein Zeichen (char) ist. Aber:
%d im Text bedeutet, dass eine Zahl auszugeben ist.
ein char kann ja auch als Zahl interpretiert werden.
Es wird also 65 (der ASCII-Wert von 'A') ausgegeben. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer char Variablen!

'''Bildschirm löschen'''

Oft sind von anderen Programmen noch "Rückstände" vorhanden. Nicht nur um die zu beseitigen, brauchen Sie einen "Bildschirm-Lösch-Befehl". Dieser ist in conio.h definiert und nennt sich "clrscr" ("clear screen", deut: "lösche Bildschirm").
<pre>
#include <conio.h>
#include <stdio.h>

void main(void)
{
clrscr();
...
}
</pre>

==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.
Der wichtigste Befehl ist "scanf". Er liest Daten von der Tastatur. Die Syntax entspricht derer von printf, nur daß man außer den %c und %d keine weiteren Angaben im "Text" machen darf:

<pre>
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. Diese Zahl wird in Zahl1 abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

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

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

===getch===
getch ist eine Funktion (Siehe Kapitel Unterprogramme), die ein char-Zeichen von der Tastatur einliest. Dazu geben Sie im Programm einfach folgende Zeile an:

<pre>
char zeichen;
zeichen = getch();
</pre>
Diese Zeile erwartet die Eingabe eines char-Zeichens. Im Gegensatz zu scanf muß man nach der Eingabe des Zeichens jedoch nicht [ENTER] drücken, um die Eingabe zu bestätigen. In der Variable zeichen wird das erste Zeichen gespeichert, das auf der Tastatur eingegeben wird.

Eine weiter Möglichkeit der Anwendung von getch ist es, wenn Sie einfach "getch();" als Befehl eingeben. Dann wartet der Computer, bis Sie eine Taste drücken, speichert diese aber nicht ab.

===kbhit===
Dies ist ebenfalls eine Funktion, die eine boolschen Ausdruck zurück liefert. Sie gibt Bescheid darüber, ob eine Taste gedrückt wurde, und mit scanf oder getch abgerufen werden kann (zum Verständnis: auf der Tastatur eingegebene Zeichen werden meist nicht direkt vom Programm verarbeitet, sondern erst vom Betriebssystem bzw. dem BIOS des Computers gespeichert. Wenn das Programm nun eine Eingabe erwartet, werden die gespeicherten Zeichen "verwendet". Dies lauft jedoch so schnell ab, daß der Benutzer davon nichts merkt). Ist diese Variable TRUE, dann ist ein Zeichen abfragebereit, sonst nicht:

<pre>
while ( !kbhit() )
{
Zahl1=Zahl1+1;
printf("%d\n",Zahl1);
}
</pre>

Dieser Programmteil erhöht solange Zahl1 und gibt diese aus, bis der Benutzer eine Taste drückt.

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

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

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

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

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

void main(void)
{
int zahl1,ergebnis;

printf("Bitte Zahl eingeben: ");
scanf("%d",&zahl1);
ergebnis = hoch2(zahl1);
printf("%d hoch 2 = %d\n",zahl1,ergebnis);
printf("5 hoch 2 = %d\n",hoch2(5));
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen.
Geschachtelte-Unterprogramme wie z.B. in Pascal sind nicht möglich.
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Bei z.B. getch() ist das char. Danach folgt der Name der Funktion (case-sensitiv!). Danach kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden, und mittels Beistrich voneinander getrennt werden. Am Ende ist kein Beistrich!
Im Block der Funktion können alle Anweisungen ausgeführt werden und Variablen deklariert werden.
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung "return" und dem Rückgabewert.
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an "Variable=Funktion(Parameter);". Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

==Prozedur==
'''Syntax:''' void Name(Parameterliste);

Eine Prozedur ist nichts anderes als eine Funktion ohne Rückgabewert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede:

Als Rückgabe-Datentyp wird void angegeben.
Eine Prozedur kann daher beim Aufruf nicht einer Variablen zugewiesen werden (wie FUNCTION's) sonder wird wie eine normale Anweisung behandelt (wie z.B. printf).

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

void ausgeben(int Param1);
{
printf("Der Wert der Variablen beträgt: %d\n",Param1);
}

void main(void)
{
int Zahl1;
ausgeben(23);
Zahl1=4;
ausgeben(Zahl1);
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Durch den Befehl "ausgeben(23)" wird die Prozedur "ausgeben" mit dem Parameter 23 aufgerufen. Param1 hat also den Wert 23. Die einzige Anweisung innerhalb der Prozedur ist printf, was nun ausgeführt wird.
Danach wird mit dem nächsten Befehl innerhalb des Hauptprogrammes fortgefahren ("Zahl1=4").
Der 2. Aufruf von ausgeben erfolgt mit dem Parameter Zahl1, also wird Param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels printf ausgeben.
Unterprogramme ohne Parameter
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, z.B. main, haben statt der Parameter immer nur void stehen. Was bedeutet das? Nun ja, C erwartet, das Sie die Parameter angeben. void bedeutet "es gibt keine Parameter". "void main(void)" bedeutet also: "Erstelle ein Unterprogramm Namens main, das keinen Rückgabewert und keine Parameter hat".

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, z.B. getch, müssen Sie beim Aufruf trotzdem die Klammern angeben. Der Befehl "getch;" führt nicht getch ohne Parameter aus, sondern liefert die Adresse der Funktion getch. Alles klar? Na ja, jedenfalls: Beim Aufruf jedes Unterpgrogrammes immmer Klammern angeben.
}}

==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 1. Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Definition davor erledigt haben. Verstanden?
Um dies zu erreichen, gibt es zwei Möglichkeiten:

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

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

void ausgeben(int Zahl); //Der Prototyp

void main(void)
{
clrscr();
ausgeben(12);
getch();
}

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 [[C-Tutorial#Zeiger | Zeiger]] übergeben werden.
# Werden [[C-Tutorial#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:
<pre>
void erhoehe(int x)
{
x = x + 1;
}

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

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 x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.

<pre>
void erhoehe(int *x)
{
/* erhöhe den Wert an der Adresse x um eins */
*x = *x + 1;
}

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

Jetzt wird im Hauptprogramm mittels [[C-Tutorial#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 Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.

=Besondere Datentypen=

==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 <conio.h>
#include <stdio.h>
#include <string.h>

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

strcpy(stri1,"hallo");
clrscr();
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);
getch();
}
</pre>

'''Hinweis:'''
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, brauchen Sie kein & bei scanf angeben!

'''Erklärung:'''
Es werden 2 gleich große Strings definiert: stri1 und eingabe, mit je 20 "nutzbaren" Zeichen.
stri1 wird der Wert "hallo" zugewiesen. Das 0-Zeichen wird automatisch angefügt!
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt %s ins Spiel. Es hat die gleiche Aufgabe wie %d oder %c, nur halt für Strings.
Sie werden gebeten, eine String einzugeben.
Dieser String wird danach in die Variable stri1 kopiert.
Beide Strings (die ja nun auch den selben Wert haben) werden ausgegeben.

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

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

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

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

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

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

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

void main(void)
{
int Zahl;
printf("Zahl eingeben: ");
scanf("%d",&Zahl);
erhoehe(&Zahl);
printf("\nDie erhoehte Zahl lautet: %d\n",Zahl);
getch();
}
</pre>

==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: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
void 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>

void 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!

'''Autoren'''
* Plasma
* Bernd

'''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://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

2006-04-30T08:41:42Z

Johannuhrmann: /* Parameterübergabe */

Ein kurzer Einblick in die Programmiersprache C
=Allgemeines=
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 Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.

C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu 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.
<pre>
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

/* Anweisungen */
return 0;
}
</pre>

Die Beschreibung (die Erklärungen folgen):

;<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ücksichtige, 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 Unterprogramm main=
Unterprogramme lernen Sie zwar erst später kennen, aber dieses eine muß sein. In Gegensatz zu anderen Programmiersprachen gibt es in C kein "Hauptprogramm", sondern nur Unterprogramme. Aber woher soll der Computer wissen, welches Unterprogramm er am Beginn ausführen soll? Ganz einfach, er führt immer das Unterprogramm "main" aus. Dieses ist sozusagen 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 Integer Wert als Ergebnis zurückgeliefert. Beim [[Microcontroller]] ist main das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es dann also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß main oft als oft auch als void (Parameterfrei) definiert wird, wie oben im Beispiel zu erkennen. 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.
<pre>
/* void Definition von main ist nur beim Controller üblich
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main
* kein Fehler/Warnung erzeugt wird.
*/
void main(void)
{
}
</pre>
Was das bedeutet, lernen Sie in einem späteren Kapitel. Wichtig ist nur: ohne main ist kein Programm komplett, es lässt sich dann auch nicht ausführen!

=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":

<pre>
void main(void)
{ //der Block "main" beginnt
int Zahl;

{ //ein "namenloser" Block beginnt
//hier stehen Anweisungen
} //der "namenlose" Block endet
} //der Block "main" endet
</pre>

'''Bemerkung:'''
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, und welcher Art diese Daten sind. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können Sie alle möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können).

;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 ab!

===int, char, short, long (ganze Zahlen)===
In Variable dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, -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 recht 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>

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

=== 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 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: In Zukunft werden ich oft 1 als Synonym für "ungleich 0" verwenden. Bitte beachten Sie jedoch, das eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

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

==Zusammengesetzte Datentypen==
===Felder===
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 Felder, sogenannte ''Arrays'', zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits bekanntes Beispiel für ein Array ist ein String. Ein String ist nichts anderes als ein Array des Datentypes char.

'''Syntax:''' Datentyp Variablenname[Anzahl]

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

int main(void)
{
int Zaehler;
int Zahlen[10]; //Zahlen[0] bis Zahlen[9] !!!

for (Zaehler=0; Zaehler<10; Zaehler++)
{
printf ("Bitte Zahl %d eingeben: ", Zaehler);
scanf ("%d", & Zahlen[Zaehler]);
printf ("\n");
}
printf ("Super!\n");
for (Zaehler=0; Zaehler<10; Zaehler++)
printf ("Zahl %d war: %d\n", Zaehler, Zahlen[Zaehler]);
</pre>

'''Bemerkungen:'''
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.

{{FarbigerRahmen|
'''Merke:'''
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!
}}

===Mehrdimensionale Felder===
Manchmal benötigen 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.

==Strings (Zeichenketten)==
Bei einem String handelt es sich um ein Array, das aus einzelnen Zeichen 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.

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

<pre>
struct Person {
char vname[20], nname[20];
char telnr[15];
int alter;
};
</pre>

'''Erklärung:'''
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden 4 Variablen angelege: 3 Strings und ein <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach
struct Person Variablenname;
an.

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:
<pre>
struct Person hubert;

hubert.alter = 32;
</pre>

==Zeiger==
Jede Variable steht an einer genau definierten stelle im Speicher. Diese Stelle kann man in erfahrung bringen. Wie man das macht und was das überhaupt für Vorteile bringt, erfahren Sie in diesem Abschnitt.
Ein Zeiger ist im Prinzip eine (int-) Variable. In ihr ist jedoch keine Zahl gespeichert, sondern eine "Adresse". Diese gibt eine bestimmte Position im Arbeitsspeicher dar. Hier sehen Sie, wie man einen Zeiger definiert und mit ihm arbeitet:

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

void main(void)
{
int Zahl;
int *Zeiger;

Zeiger=&Zahl;
*Zeiger=12;

printf("%d = %d", Zahl, *Zeiger);
</pre>

'''Erklärung:'''
Um einen Zeiger anzulegen, gibt man folgendes an: Datentyp, dann einen Stern (*), anschließend den Namen (und einen Strichpunkt).
Um einen Zeiger auf eine bestimmte Zahl "zeigen" zu lassen, muß man dem Zeiger die Adresse einer Variablen zuordnen. Das funktioniert mittels dem Adress-Operator & (Zeiger=&Zahl).
Jetzt möchten Sie dem Zeiger einen Wert zuweisen. Aber natürlich nicht dem Zeiger, sondern der Variablen, auf die der Zeiger "zeigt". Na, "Zahl=Wert;", werden Sie sagen. Aber wozu dann Zeiger? Na, ja, jednefalls geht das mittels des "Inhalts-Operators" * (*Zeiger=12).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an printf (und jedes andere Unterprogramm) übergeben.

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

Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.
==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!
<pre>
int Zahl1, Zahl2;
char Zeichen;

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

return 0;
}
</pre>
;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 Zahl1 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 int und char dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable FALSE, ansonsten ist Sie TRUE.
intVariable = !0; // entspricht TRUE
intVariable = 0; // entspricht FALSE

==Vergleich von Variablen==
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln:
<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>
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl.
intVariable = Zahl1 <= Zahl2;
das komplette Beispiel zeigt es deutlicher:
<pre>
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */

printf ("Ergebnis: %d\n", i);
</pre>
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").

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

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

==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>: 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.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert.
Eine Variable ist so ein LValue, der etwas zugewiesen werden kann:
a = 1;
Hingegen ist <tt>a+1</tt> kein LValue, denn eine Zuweisung wie
a+1 = 2;
erzeugt einen Compilerfehler, der etwas lautet könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

==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 Eigenheit der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet.

Beispiel:
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */

<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,
die eine aufwändige Operation durchführt.
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.

Wo ist also der Unterschied? 
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.

==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==
==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:
<pre>
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */

/* z ist ein Zeiger auf eine Integervariable und enthält somit
die Speicheradresse einer Integervariablen
*/
int *z;

/* Verwendung des Adressoperators... */
z = &x; /* weise z die Speicheradresse von x zu */

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

/* da z auf x zeigt, hat auch x jetzt den Wert 6 */
</pre>

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

Statt
(*strukturZeiger).element
kann geschrieben werden
strukturZeiger->element
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

{{FarbigerRahmen |
'''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:

<pre>
int *z; /* z ist ein Zeiger auf einen Integer */

/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.
z enthält irgendeine(!) Adresse
*/

/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */
*z = *z + 1;
</pre>

Viele C-Compiler (z.B. gcc) 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.

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

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingte Zuweisung===
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;

==Blöcke==
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks.
Der Block muss un runden Klammern stehen:
int sum;
sum = ({
int i, s = 0;
for (i=1; i<= 100; i++)
s += i;
s;
});

Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc,
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer
Instruktion nicht machbar wäre:
<pre>
#define PSTR(s) \
({ \
static char __c[] PROGMEM = (s); \
__c; \
})
</pre>

==Reihenfolge der Auswertung==

=Kontrollanweisungen=

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

b1= b2 && b3;

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

b1= b2 || b3;

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

b1= !b2;

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

==<tt>if</tt>-Anweisung==
Syntax: IF (Bedingung) Anweisung;
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:

[[bild:ifthenelse.png]]

Und in C schreibt man:
<pre>
if (Bedingung) // WENN
{ // DANN
Anweisung1;
}
else
{ // SONST
Anweisung2;
}
</pre>
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.

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

<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki>

<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki>

Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.
}}

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

===<tt>while</tt>-Schleife===
'''Syntax:''' while (Bedingung) { Anweisung; }

Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block!

<pre>
Zahl1=0;
while (Zahl1<3)
{
Zahl1=Zahl1+1;
Zahl2=Zahl2*2;
}
</pre>

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.
===<tt>do</tt>-<tt>while</tt>-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. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird

<pre>
unsigned char bData;
do {
bData = getch(); // Tastatureingabe (s.u.)
}while (bData != 13);
</pre>

Die Schleife wird durchlaufen und wiederholt, solange etwas anderes als 13 (<ENTER>) eingegeben wird.

===<tt>for</tt>-Schleife===
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }

Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Hat sie einen bestimmten Wert erreicht, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block

Die gesammte Schleife wird solange durchgeführt, wie die Bedingung TRUE ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.

Die Theorie ist schwer, die Praxis nicht so sehr...

<pre>
int Zaehler;
for (Zaehler = 1; Zaehler <= 10; Zaehler++)
{
Zahl2 = Zahl2 + Zaehler;
}
</pre>
Das Äquivalent als "WHILE"
<pre>
int Zaehler;
Zaehler = 1; // Anfangswerte
while (Zaehler <= 10) // Bedingung
{
Zahl2 = Zahl2 + Zaehler;
Zaehler++; // Inkrement
}
</pre>

In diesem Beispiel wird Zahl2 in jedem Schleifendurchlauf um die Zählvariable Zaehler erhöht. Da Zaehler nacheinander die Werte von 1 bis 10 hat, ist in Zahl2 nach der Schleife die Summe der Zahlen 1 bis 10 gespeichert.

'''Erklärung:'''
Zaehler=1 bedeutet, dass der Variablen Zaehler vor dem 1. Schleifendurchlauf der Wert 1 zugewiesen wird.
Zaehler<=10 ist die Schleifenbedingung; ist sie FALSE, wird die Schleife beendet.
Zaehler++ bedeutet, dass Zaehler nach jedem Durchlauf um 1 erhöht wird.

=Ein- und Ausgabe=

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

Der dazu notwendige Befehl ist printf (das f ist KEIN Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf dem Bildschirm aus (außer, Sie haben unter DOS die Standard-Ausgabe auf ein anderes Gerät, z.B. den Drucker umgeleitet, aber das ist eine andere Geschichte). Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. int, char, float, double) sein!
<pre>
#include <conio.h>
#include <stdio.h>

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

Hinweis:
Dass das Programm nach dem Compilieren und Ausführen sofort wieder beendet wird, ist nicht Ihr Fehler. Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!
Erklärung:

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

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

In der 3. Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet %c "char" (Zeichen). Es wird also %c durch 'A' ersetzt.

Die letzte Ausgabe verhält sich merkwürdig es wird doch tatsächlich eine Zahl ausgegeben, obwohl der Parameter ein Zeichen (char) ist. Aber:
%d im Text bedeutet, dass eine Zahl auszugeben ist.
ein char kann ja auch als Zahl interpretiert werden.
Es wird also 65 (der ASCII-Wert von 'A') ausgegeben. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer char Variablen!

'''Bildschirm löschen'''

Oft sind von anderen Programmen noch "Rückstände" vorhanden. Nicht nur um die zu beseitigen, brauchen Sie einen "Bildschirm-Lösch-Befehl". Dieser ist in conio.h definiert und nennt sich "clrscr" ("clear screen", deut: "lösche Bildschirm").
<pre>
#include <conio.h>
#include <stdio.h>

void main(void)
{
clrscr();
...
}
</pre>

==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.
Der wichtigste Befehl ist "scanf". Er liest Daten von der Tastatur. Die Syntax entspricht derer von printf, nur daß man außer den %c und %d keine weiteren Angaben im "Text" machen darf:

<pre>
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. Diese Zahl wird in Zahl1 abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

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

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

===getch===
getch ist eine Funktion (Siehe Kapitel Unterprogramme), die ein char-Zeichen von der Tastatur einliest. Dazu geben Sie im Programm einfach folgende Zeile an:

<pre>
char zeichen;
zeichen = getch();
</pre>
Diese Zeile erwartet die Eingabe eines char-Zeichens. Im Gegensatz zu scanf muß man nach der Eingabe des Zeichens jedoch nicht [ENTER] drücken, um die Eingabe zu bestätigen. In der Variable zeichen wird das erste Zeichen gespeichert, das auf der Tastatur eingegeben wird.

Eine weiter Möglichkeit der Anwendung von getch ist es, wenn Sie einfach "getch();" als Befehl eingeben. Dann wartet der Computer, bis Sie eine Taste drücken, speichert diese aber nicht ab.

===kbhit===
Dies ist ebenfalls eine Funktion, die eine boolschen Ausdruck zurück liefert. Sie gibt Bescheid darüber, ob eine Taste gedrückt wurde, und mit scanf oder getch abgerufen werden kann (zum Verständnis: auf der Tastatur eingegebene Zeichen werden meist nicht direkt vom Programm verarbeitet, sondern erst vom Betriebssystem bzw. dem BIOS des Computers gespeichert. Wenn das Programm nun eine Eingabe erwartet, werden die gespeicherten Zeichen "verwendet". Dies lauft jedoch so schnell ab, daß der Benutzer davon nichts merkt). Ist diese Variable TRUE, dann ist ein Zeichen abfragebereit, sonst nicht:

<pre>
while ( !kbhit() )
{
Zahl1=Zahl1+1;
printf("%d\n",Zahl1);
}
</pre>

Dieser Programmteil erhöht solange Zahl1 und gibt diese aus, bis der Benutzer eine Taste drückt.

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

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

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

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

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

void main(void)
{
int zahl1,ergebnis;

printf("Bitte Zahl eingeben: ");
scanf("%d",&zahl1);
ergebnis = hoch2(zahl1);
printf("%d hoch 2 = %d\n",zahl1,ergebnis);
printf("5 hoch 2 = %d\n",hoch2(5));
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen.
Geschachtelte-Unterprogramme wie z.B. in Pascal sind nicht möglich.
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Bei z.B. getch() ist das char. Danach folgt der Name der Funktion (case-sensitiv!). Danach kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden, und mittels Beistrich voneinander getrennt werden. Am Ende ist kein Beistrich!
Im Block der Funktion können alle Anweisungen ausgeführt werden und Variablen deklariert werden.
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung "return" und dem Rückgabewert.
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an "Variable=Funktion(Parameter);". Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

==Prozedur==
'''Syntax:''' void Name(Parameterliste);

Eine Prozedur ist nichts anderes als eine Funktion ohne Rückgabewert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede:

Als Rückgabe-Datentyp wird void angegeben.
Eine Prozedur kann daher beim Aufruf nicht einer Variablen zugewiesen werden (wie FUNCTION's) sonder wird wie eine normale Anweisung behandelt (wie z.B. printf).

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

void ausgeben(int Param1);
{
printf("Der Wert der Variablen beträgt: %d\n",Param1);
}

void main(void)
{
int Zahl1;
ausgeben(23);
Zahl1=4;
ausgeben(Zahl1);
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Durch den Befehl "ausgeben(23)" wird die Prozedur "ausgeben" mit dem Parameter 23 aufgerufen. Param1 hat also den Wert 23. Die einzige Anweisung innerhalb der Prozedur ist printf, was nun ausgeführt wird.
Danach wird mit dem nächsten Befehl innerhalb des Hauptprogrammes fortgefahren ("Zahl1=4").
Der 2. Aufruf von ausgeben erfolgt mit dem Parameter Zahl1, also wird Param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels printf ausgeben.
Unterprogramme ohne Parameter
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, z.B. main, haben statt der Parameter immer nur void stehen. Was bedeutet das? Nun ja, C erwartet, das Sie die Parameter angeben. void bedeutet "es gibt keine Parameter". "void main(void)" bedeutet also: "Erstelle ein Unterprogramm Namens main, das keinen Rückgabewert und keine Parameter hat".

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, z.B. getch, müssen Sie beim Aufruf trotzdem die Klammern angeben. Der Befehl "getch;" führt nicht getch ohne Parameter aus, sondern liefert die Adresse der Funktion getch. Alles klar? Na ja, jedenfalls: Beim Aufruf jedes Unterpgrogrammes immmer Klammern angeben.
}}

==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 1. Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Definition davor erledigt haben. Verstanden?
Um dies zu erreichen, gibt es zwei Möglichkeiten:

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

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

void ausgeben(int Zahl); //Der Prototyp

void main(void)
{
clrscr();
ausgeben(12);
getch();
}

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 [[C-Tutorial#Zeiger | Zeiger]] übergeben werden.
# Werden [[C-Tutorial#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:
<pre>
void erhoehe(int x)
{
x = x + 1;
}

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

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 x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.

<pre>
void erhoehe(int *x)
{
/* erhöhe den Wert an der Adresse x um eins */
*x = *x + 1;
}

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

Jetzt wird im Hauptprogramm mittels [[C-Tutorial#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 Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.

=Besondere Datentypen=

==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 <conio.h>
#include <stdio.h>
#include <string.h>

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

strcpy(stri1,"hallo");
clrscr();
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);
getch();
}
</pre>

'''Hinweis:'''
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, brauchen Sie kein & bei scanf angeben!

'''Erklärung:'''
Es werden 2 gleich große Strings definiert: stri1 und eingabe, mit je 20 "nutzbaren" Zeichen.
stri1 wird der Wert "hallo" zugewiesen. Das 0-Zeichen wird automatisch angefügt!
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt %s ins Spiel. Es hat die gleiche Aufgabe wie %d oder %c, nur halt für Strings.
Sie werden gebeten, eine String einzugeben.
Dieser String wird danach in die Variable stri1 kopiert.
Beide Strings (die ja nun auch den selben Wert haben) werden ausgegeben.

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

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

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

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

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

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

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

void main(void)
{
int Zahl;
printf("Zahl eingeben: ");
scanf("%d",&Zahl);
erhoehe(&Zahl);
printf("\nDie erhoehte Zahl lautet: %d\n",Zahl);
getch();
}
</pre>

==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: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
void 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>

void 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!

'''Autoren'''
* Plasma
* Bernd

'''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://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

2006-04-30T08:39:54Z

Johannuhrmann: Parameterübergabe

Ein kurzer Einblick in die Programmiersprache C
=Allgemeines=
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 Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.

C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu 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.
<pre>
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

/* Anweisungen */
return 0;
}
</pre>

Die Beschreibung (die Erklärungen folgen):

;<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ücksichtige, 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 Unterprogramm main=
Unterprogramme lernen Sie zwar erst später kennen, aber dieses eine muß sein. In Gegensatz zu anderen Programmiersprachen gibt es in C kein "Hauptprogramm", sondern nur Unterprogramme. Aber woher soll der Computer wissen, welches Unterprogramm er am Beginn ausführen soll? Ganz einfach, er führt immer das Unterprogramm "main" aus. Dieses ist sozusagen 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 Integer Wert als Ergebnis zurückgeliefert. Beim [[Microcontroller]] ist main das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es dann also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß main oft als oft auch als void (Parameterfrei) definiert wird, wie oben im Beispiel zu erkennen. 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.
<pre>
/* void Definition von main ist nur beim Controller üblich
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main
* kein Fehler/Warnung erzeugt wird.
*/
void main(void)
{
}
</pre>
Was das bedeutet, lernen Sie in einem späteren Kapitel. Wichtig ist nur: ohne main ist kein Programm komplett, es lässt sich dann auch nicht ausführen!

=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":

<pre>
void main(void)
{ //der Block "main" beginnt
int Zahl;

{ //ein "namenloser" Block beginnt
//hier stehen Anweisungen
} //der "namenlose" Block endet
} //der Block "main" endet
</pre>

'''Bemerkung:'''
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, und welcher Art diese Daten sind. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können Sie alle möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können).

;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 ab!

===int, char, short, long (ganze Zahlen)===
In Variable dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, -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 recht 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>

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

=== 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 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: In Zukunft werden ich oft 1 als Synonym für "ungleich 0" verwenden. Bitte beachten Sie jedoch, das eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

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

==Zusammengesetzte Datentypen==
===Felder===
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 Felder, sogenannte ''Arrays'', zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits bekanntes Beispiel für ein Array ist ein String. Ein String ist nichts anderes als ein Array des Datentypes char.

'''Syntax:''' Datentyp Variablenname[Anzahl]

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

int main(void)
{
int Zaehler;
int Zahlen[10]; //Zahlen[0] bis Zahlen[9] !!!

for (Zaehler=0; Zaehler<10; Zaehler++)
{
printf ("Bitte Zahl %d eingeben: ", Zaehler);
scanf ("%d", & Zahlen[Zaehler]);
printf ("\n");
}
printf ("Super!\n");
for (Zaehler=0; Zaehler<10; Zaehler++)
printf ("Zahl %d war: %d\n", Zaehler, Zahlen[Zaehler]);
</pre>

'''Bemerkungen:'''
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.

{{FarbigerRahmen|
'''Merke:'''
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!
}}

===Mehrdimensionale Felder===
Manchmal benötigen 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.

==Strings (Zeichenketten)==
Bei einem String handelt es sich um ein Array, das aus einzelnen Zeichen 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.

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

<pre>
struct Person {
char vname[20], nname[20];
char telnr[15];
int alter;
};
</pre>

'''Erklärung:'''
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden 4 Variablen angelege: 3 Strings und ein <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach
struct Person Variablenname;
an.

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:
<pre>
struct Person hubert;

hubert.alter = 32;
</pre>

==Zeiger==
Jede Variable steht an einer genau definierten stelle im Speicher. Diese Stelle kann man in erfahrung bringen. Wie man das macht und was das überhaupt für Vorteile bringt, erfahren Sie in diesem Abschnitt.
Ein Zeiger ist im Prinzip eine (int-) Variable. In ihr ist jedoch keine Zahl gespeichert, sondern eine "Adresse". Diese gibt eine bestimmte Position im Arbeitsspeicher dar. Hier sehen Sie, wie man einen Zeiger definiert und mit ihm arbeitet:

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

void main(void)
{
int Zahl;
int *Zeiger;

Zeiger=&Zahl;
*Zeiger=12;

printf("%d = %d", Zahl, *Zeiger);
</pre>

'''Erklärung:'''
Um einen Zeiger anzulegen, gibt man folgendes an: Datentyp, dann einen Stern (*), anschließend den Namen (und einen Strichpunkt).
Um einen Zeiger auf eine bestimmte Zahl "zeigen" zu lassen, muß man dem Zeiger die Adresse einer Variablen zuordnen. Das funktioniert mittels dem Adress-Operator & (Zeiger=&Zahl).
Jetzt möchten Sie dem Zeiger einen Wert zuweisen. Aber natürlich nicht dem Zeiger, sondern der Variablen, auf die der Zeiger "zeigt". Na, "Zahl=Wert;", werden Sie sagen. Aber wozu dann Zeiger? Na, ja, jednefalls geht das mittels des "Inhalts-Operators" * (*Zeiger=12).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an printf (und jedes andere Unterprogramm) übergeben.

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

Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.
==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!
<pre>
int Zahl1, Zahl2;
char Zeichen;

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

return 0;
}
</pre>
;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 Zahl1 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 int und char dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable FALSE, ansonsten ist Sie TRUE.
intVariable = !0; // entspricht TRUE
intVariable = 0; // entspricht FALSE

==Vergleich von Variablen==
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln:
<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>
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl.
intVariable = Zahl1 <= Zahl2;
das komplette Beispiel zeigt es deutlicher:
<pre>
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */

printf ("Ergebnis: %d\n", i);
</pre>
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").

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

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

==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>: 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.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert.
Eine Variable ist so ein LValue, der etwas zugewiesen werden kann:
a = 1;
Hingegen ist <tt>a+1</tt> kein LValue, denn eine Zuweisung wie
a+1 = 2;
erzeugt einen Compilerfehler, der etwas lautet könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

==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 Eigenheit der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet.

Beispiel:
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */

<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,
die eine aufwändige Operation durchführt.
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.

Wo ist also der Unterschied? 
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.

==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==
==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:
<pre>
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */

/* z ist ein Zeiger auf eine Integervariable und enthält somit
die Speicheradresse einer Integervariablen
*/
int *z;

/* Verwendung des Adressoperators... */
z = &x; /* weise z die Speicheradresse von x zu */

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

/* da z auf x zeigt, hat auch x jetzt den Wert 6 */
</pre>

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

Statt
(*strukturZeiger).element
kann geschrieben werden
strukturZeiger->element
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

{{FarbigerRahmen |
'''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:

<pre>
int *z; /* z ist ein Zeiger auf einen Integer */

/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.
z enthält irgendeine(!) Adresse
*/

/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */
*z = *z + 1;
</pre>

Viele C-Compiler (z.B. gcc) 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.

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

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingte Zuweisung===
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;

==Blöcke==
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks.
Der Block muss un runden Klammern stehen:
int sum;
sum = ({
int i, s = 0;
for (i=1; i<= 100; i++)
s += i;
s;
});

Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc,
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer
Instruktion nicht machbar wäre:
<pre>
#define PSTR(s) \
({ \
static char __c[] PROGMEM = (s); \
__c; \
})
</pre>

==Reihenfolge der Auswertung==

=Kontrollanweisungen=

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

b1= b2 && b3;

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

b1= b2 || b3;

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

b1= !b2;

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

==<tt>if</tt>-Anweisung==
Syntax: IF (Bedingung) Anweisung;
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:

[[bild:ifthenelse.png]]

Und in C schreibt man:
<pre>
if (Bedingung) // WENN
{ // DANN
Anweisung1;
}
else
{ // SONST
Anweisung2;
}
</pre>
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.

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

<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki>

<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki>

Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.
}}

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

===<tt>while</tt>-Schleife===
'''Syntax:''' while (Bedingung) { Anweisung; }

Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block!

<pre>
Zahl1=0;
while (Zahl1<3)
{
Zahl1=Zahl1+1;
Zahl2=Zahl2*2;
}
</pre>

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.
===<tt>do</tt>-<tt>while</tt>-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. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird

<pre>
unsigned char bData;
do {
bData = getch(); // Tastatureingabe (s.u.)
}while (bData != 13);
</pre>

Die Schleife wird durchlaufen und wiederholt, solange etwas anderes als 13 (<ENTER>) eingegeben wird.

===<tt>for</tt>-Schleife===
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }

Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Hat sie einen bestimmten Wert erreicht, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block

Die gesammte Schleife wird solange durchgeführt, wie die Bedingung TRUE ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.

Die Theorie ist schwer, die Praxis nicht so sehr...

<pre>
int Zaehler;
for (Zaehler = 1; Zaehler <= 10; Zaehler++)
{
Zahl2 = Zahl2 + Zaehler;
}
</pre>
Das Äquivalent als "WHILE"
<pre>
int Zaehler;
Zaehler = 1; // Anfangswerte
while (Zaehler <= 10) // Bedingung
{
Zahl2 = Zahl2 + Zaehler;
Zaehler++; // Inkrement
}
</pre>

In diesem Beispiel wird Zahl2 in jedem Schleifendurchlauf um die Zählvariable Zaehler erhöht. Da Zaehler nacheinander die Werte von 1 bis 10 hat, ist in Zahl2 nach der Schleife die Summe der Zahlen 1 bis 10 gespeichert.

'''Erklärung:'''
Zaehler=1 bedeutet, dass der Variablen Zaehler vor dem 1. Schleifendurchlauf der Wert 1 zugewiesen wird.
Zaehler<=10 ist die Schleifenbedingung; ist sie FALSE, wird die Schleife beendet.
Zaehler++ bedeutet, dass Zaehler nach jedem Durchlauf um 1 erhöht wird.

=Ein- und Ausgabe=

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

Der dazu notwendige Befehl ist printf (das f ist KEIN Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf dem Bildschirm aus (außer, Sie haben unter DOS die Standard-Ausgabe auf ein anderes Gerät, z.B. den Drucker umgeleitet, aber das ist eine andere Geschichte). Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. int, char, float, double) sein!
<pre>
#include <conio.h>
#include <stdio.h>

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

Hinweis:
Dass das Programm nach dem Compilieren und Ausführen sofort wieder beendet wird, ist nicht Ihr Fehler. Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!
Erklärung:

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

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

In der 3. Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet %c "char" (Zeichen). Es wird also %c durch 'A' ersetzt.

Die letzte Ausgabe verhält sich merkwürdig es wird doch tatsächlich eine Zahl ausgegeben, obwohl der Parameter ein Zeichen (char) ist. Aber:
%d im Text bedeutet, dass eine Zahl auszugeben ist.
ein char kann ja auch als Zahl interpretiert werden.
Es wird also 65 (der ASCII-Wert von 'A') ausgegeben. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer char Variablen!

'''Bildschirm löschen'''

Oft sind von anderen Programmen noch "Rückstände" vorhanden. Nicht nur um die zu beseitigen, brauchen Sie einen "Bildschirm-Lösch-Befehl". Dieser ist in conio.h definiert und nennt sich "clrscr" ("clear screen", deut: "lösche Bildschirm").
<pre>
#include <conio.h>
#include <stdio.h>

void main(void)
{
clrscr();
...
}
</pre>

==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.
Der wichtigste Befehl ist "scanf". Er liest Daten von der Tastatur. Die Syntax entspricht derer von printf, nur daß man außer den %c und %d keine weiteren Angaben im "Text" machen darf:

<pre>
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. Diese Zahl wird in Zahl1 abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

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

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

===getch===
getch ist eine Funktion (Siehe Kapitel Unterprogramme), die ein char-Zeichen von der Tastatur einliest. Dazu geben Sie im Programm einfach folgende Zeile an:

<pre>
char zeichen;
zeichen = getch();
</pre>
Diese Zeile erwartet die Eingabe eines char-Zeichens. Im Gegensatz zu scanf muß man nach der Eingabe des Zeichens jedoch nicht [ENTER] drücken, um die Eingabe zu bestätigen. In der Variable zeichen wird das erste Zeichen gespeichert, das auf der Tastatur eingegeben wird.

Eine weiter Möglichkeit der Anwendung von getch ist es, wenn Sie einfach "getch();" als Befehl eingeben. Dann wartet der Computer, bis Sie eine Taste drücken, speichert diese aber nicht ab.

===kbhit===
Dies ist ebenfalls eine Funktion, die eine boolschen Ausdruck zurück liefert. Sie gibt Bescheid darüber, ob eine Taste gedrückt wurde, und mit scanf oder getch abgerufen werden kann (zum Verständnis: auf der Tastatur eingegebene Zeichen werden meist nicht direkt vom Programm verarbeitet, sondern erst vom Betriebssystem bzw. dem BIOS des Computers gespeichert. Wenn das Programm nun eine Eingabe erwartet, werden die gespeicherten Zeichen "verwendet". Dies lauft jedoch so schnell ab, daß der Benutzer davon nichts merkt). Ist diese Variable TRUE, dann ist ein Zeichen abfragebereit, sonst nicht:

<pre>
while ( !kbhit() )
{
Zahl1=Zahl1+1;
printf("%d\n",Zahl1);
}
</pre>

Dieser Programmteil erhöht solange Zahl1 und gibt diese aus, bis der Benutzer eine Taste drückt.

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

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

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

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

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

void main(void)
{
int zahl1,ergebnis;

printf("Bitte Zahl eingeben: ");
scanf("%d",&zahl1);
ergebnis = hoch2(zahl1);
printf("%d hoch 2 = %d\n",zahl1,ergebnis);
printf("5 hoch 2 = %d\n",hoch2(5));
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen.
Geschachtelte-Unterprogramme wie z.B. in Pascal sind nicht möglich.
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Bei z.B. getch() ist das char. Danach folgt der Name der Funktion (case-sensitiv!). Danach kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden, und mittels Beistrich voneinander getrennt werden. Am Ende ist kein Beistrich!
Im Block der Funktion können alle Anweisungen ausgeführt werden und Variablen deklariert werden.
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung "return" und dem Rückgabewert.
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an "Variable=Funktion(Parameter);". Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

==Prozedur==
'''Syntax:''' void Name(Parameterliste);

Eine Prozedur ist nichts anderes als eine Funktion ohne Rückgabewert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede:

Als Rückgabe-Datentyp wird void angegeben.
Eine Prozedur kann daher beim Aufruf nicht einer Variablen zugewiesen werden (wie FUNCTION's) sonder wird wie eine normale Anweisung behandelt (wie z.B. printf).

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

void ausgeben(int Param1);
{
printf("Der Wert der Variablen beträgt: %d\n",Param1);
}

void main(void)
{
int Zahl1;
ausgeben(23);
Zahl1=4;
ausgeben(Zahl1);
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Durch den Befehl "ausgeben(23)" wird die Prozedur "ausgeben" mit dem Parameter 23 aufgerufen. Param1 hat also den Wert 23. Die einzige Anweisung innerhalb der Prozedur ist printf, was nun ausgeführt wird.
Danach wird mit dem nächsten Befehl innerhalb des Hauptprogrammes fortgefahren ("Zahl1=4").
Der 2. Aufruf von ausgeben erfolgt mit dem Parameter Zahl1, also wird Param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels printf ausgeben.
Unterprogramme ohne Parameter
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, z.B. main, haben statt der Parameter immer nur void stehen. Was bedeutet das? Nun ja, C erwartet, das Sie die Parameter angeben. void bedeutet "es gibt keine Parameter". "void main(void)" bedeutet also: "Erstelle ein Unterprogramm Namens main, das keinen Rückgabewert und keine Parameter hat".

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, z.B. getch, müssen Sie beim Aufruf trotzdem die Klammern angeben. Der Befehl "getch;" führt nicht getch ohne Parameter aus, sondern liefert die Adresse der Funktion getch. Alles klar? Na ja, jedenfalls: Beim Aufruf jedes Unterpgrogrammes immmer Klammern angeben.
}}

==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 1. Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Definition davor erledigt haben. Verstanden?
Um dies zu erreichen, gibt es zwei Möglichkeiten:

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

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

void ausgeben(int Zahl); //Der Prototyp

void main(void)
{
clrscr();
ausgeben(12);
getch();
}

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 [[C-Tutorial#Zeiger | Zeiger]] übergeben werden.
# Werden [[C-Tutorial#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:
<pre>
void erhoehe(int x)
{
x = x + 1;
}

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

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 x übergeben. Dass dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.

<pre>
void erhoehe(int *x)
{
/* erhöhe den Wert an der Adresse x um eins */
*x = *x + 1;
}

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

Jetzt wird im Hauptprogramm mittels [[C-Tutorial#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 Operator <tt>*</tt> auf den Wert an der dieser Adresse zugreifen.

=Besondere Datentypen=

==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 <conio.h>
#include <stdio.h>
#include <string.h>

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

strcpy(stri1,"hallo");
clrscr();
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);
getch();
}
</pre>

'''Hinweis:'''
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, brauchen Sie kein & bei scanf angeben!

'''Erklärung:'''
Es werden 2 gleich große Strings definiert: stri1 und eingabe, mit je 20 "nutzbaren" Zeichen.
stri1 wird der Wert "hallo" zugewiesen. Das 0-Zeichen wird automatisch angefügt!
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt %s ins Spiel. Es hat die gleiche Aufgabe wie %d oder %c, nur halt für Strings.
Sie werden gebeten, eine String einzugeben.
Dieser String wird danach in die Variable stri1 kopiert.
Beide Strings (die ja nun auch den selben Wert haben) werden ausgegeben.

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

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

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

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

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

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

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

void main(void)
{
int Zahl;
printf("Zahl eingeben: ");
scanf("%d",&Zahl);
erhoehe(&Zahl);
printf("\nDie erhoehte Zahl lautet: %d\n",Zahl);
getch();
}
</pre>

==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: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
void 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>

void 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!

'''Autoren'''
* Plasma
* Bernd

'''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://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

2006-04-30T07:58:04Z

Johannuhrmann: /* Komponenten-Auswahl bei Structs und Unions */

Ein kurzer Einblick in die Programmiersprache C
=Allgemeines=
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 Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.

C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu 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.
<pre>
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

/* Anweisungen */
return 0;
}
</pre>

Die Beschreibung (die Erklärungen folgen):

;<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ücksichtige, 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 Unterprogramm main=
Unterprogramme lernen Sie zwar erst später kennen, aber dieses eine muß sein. In Gegensatz zu anderen Programmiersprachen gibt es in C kein "Hauptprogramm", sondern nur Unterprogramme. Aber woher soll der Computer wissen, welches Unterprogramm er am Beginn ausführen soll? Ganz einfach, er führt immer das Unterprogramm "main" aus. Dieses ist sozusagen 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 Integer Wert als Ergebnis zurückgeliefert. Beim [[Microcontroller]] ist main das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es dann also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß main oft als oft auch als void (Parameterfrei) definiert wird, wie oben im Beispiel zu erkennen. 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.
<pre>
/* void Definition von main ist nur beim Controller üblich
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main
* kein Fehler/Warnung erzeugt wird.
*/
void main(void)
{
}
</pre>
Was das bedeutet, lernen Sie in einem späteren Kapitel. Wichtig ist nur: ohne main ist kein Programm komplett, es lässt sich dann auch nicht ausführen!

=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":

<pre>
void main(void)
{ //der Block "main" beginnt
int Zahl;

{ //ein "namenloser" Block beginnt
//hier stehen Anweisungen
} //der "namenlose" Block endet
} //der Block "main" endet
</pre>

'''Bemerkung:'''
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, und welcher Art diese Daten sind. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können Sie alle möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können).

;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 ab!

===int, char, short, long (ganze Zahlen)===
In Variable dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, -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 recht 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>

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

=== 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 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: In Zukunft werden ich oft 1 als Synonym für "ungleich 0" verwenden. Bitte beachten Sie jedoch, das eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

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

==Zusammengesetzte Datentypen==
===Felder===
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 Felder, sogenannte ''Arrays'', zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits bekanntes Beispiel für ein Array ist ein String. Ein String ist nichts anderes als ein Array des Datentypes char.

'''Syntax:''' Datentyp Variablenname[Anzahl]

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

int main(void)
{
int Zaehler;
int Zahlen[10]; //Zahlen[0] bis Zahlen[9] !!!

for (Zaehler=0; Zaehler<10; Zaehler++)
{
printf ("Bitte Zahl %d eingeben: ", Zaehler);
scanf ("%d", & Zahlen[Zaehler]);
printf ("\n");
}
printf ("Super!\n");
for (Zaehler=0; Zaehler<10; Zaehler++)
printf ("Zahl %d war: %d\n", Zaehler, Zahlen[Zaehler]);
</pre>

'''Bemerkungen:'''
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.

{{FarbigerRahmen|
'''Merke:'''
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!
}}

===Mehrdimensionale Felder===
Manchmal benötigen 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.

==Strings (Zeichenketten)==
Bei einem String handelt es sich um ein Array, das aus einzelnen Zeichen 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.

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

<pre>
struct Person {
char vname[20], nname[20];
char telnr[15];
int alter;
};
</pre>

'''Erklärung:'''
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden 4 Variablen angelege: 3 Strings und ein <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach
struct Person Variablenname;
an.

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:
<pre>
struct Person hubert;

hubert.alter = 32;
</pre>

==Zeiger==
Jede Variable steht an einer genau definierten stelle im Speicher. Diese Stelle kann man in erfahrung bringen. Wie man das macht und was das überhaupt für Vorteile bringt, erfahren Sie in diesem Abschnitt.
Ein Zeiger ist im Prinzip eine (int-) Variable. In ihr ist jedoch keine Zahl gespeichert, sondern eine "Adresse". Diese gibt eine bestimmte Position im Arbeitsspeicher dar. Hier sehen Sie, wie man einen Zeiger definiert und mit ihm arbeitet:

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

void main(void)
{
int Zahl;
int *Zeiger;

Zeiger=&Zahl;
*Zeiger=12;

printf("%d = %d", Zahl, *Zeiger);
</pre>

'''Erklärung:'''
Um einen Zeiger anzulegen, gibt man folgendes an: Datentyp, dann einen Stern (*), anschließend den Namen (und einen Strichpunkt).
Um einen Zeiger auf eine bestimmte Zahl "zeigen" zu lassen, muß man dem Zeiger die Adresse einer Variablen zuordnen. Das funktioniert mittels dem Adress-Operator & (Zeiger=&Zahl).
Jetzt möchten Sie dem Zeiger einen Wert zuweisen. Aber natürlich nicht dem Zeiger, sondern der Variablen, auf die der Zeiger "zeigt". Na, "Zahl=Wert;", werden Sie sagen. Aber wozu dann Zeiger? Na, ja, jednefalls geht das mittels des "Inhalts-Operators" * (*Zeiger=12).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an printf (und jedes andere Unterprogramm) übergeben.

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

Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.
==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!
<pre>
int Zahl1, Zahl2;
char Zeichen;

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

return 0;
}
</pre>
;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 Zahl1 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 int und char dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable FALSE, ansonsten ist Sie TRUE.
intVariable = !0; // entspricht TRUE
intVariable = 0; // entspricht FALSE

==Vergleich von Variablen==
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln:
<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>
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl.
intVariable = Zahl1 <= Zahl2;
das komplette Beispiel zeigt es deutlicher:
<pre>
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */

printf ("Ergebnis: %d\n", i);
</pre>
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").

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

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

==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>: 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.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert.
Eine Variable ist so ein LValue, der etwas zugewiesen werden kann:
a = 1;
Hingegen ist <tt>a+1</tt> kein LValue, denn eine Zuweisung wie
a+1 = 2;
erzeugt einen Compilerfehler, der etwas lautet könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

==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 Eigenheit der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet.

Beispiel:
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */

<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,
die eine aufwändige Operation durchführt.
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.

Wo ist also der Unterschied? 
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.

==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==
==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:
<pre>
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */

/* z ist ein Zeiger auf eine Integervariable und enthält somit
die Speicheradresse einer Integervariablen
*/
int *z;

/* Verwendung des Adressoperators... */
z = &x; /* weise z die Speicheradresse von x zu */

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

/* da z auf x zeigt, hat auch x jetzt den Wert 6 */
</pre>

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

Statt
(*strukturZeiger).element
kann geschrieben werden
strukturZeiger->element
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

{{FarbigerRahmen |
'''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:

<pre>
int *z; /* z ist ein Zeiger auf einen Integer */

/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.
z enthält irgendeine(!) Adresse
*/

/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */
*z = *z + 1;
</pre>

Viele C-Compiler (z.B. gcc) 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.

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

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingte Zuweisung===
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;

==Blöcke==
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks.
Der Block muss un runden Klammern stehen:
int sum;
sum = ({
int i, s = 0;
for (i=1; i<= 100; i++)
s += i;
s;
});

Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc,
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer
Instruktion nicht machbar wäre:
<pre>
#define PSTR(s) \
({ \
static char __c[] PROGMEM = (s); \
__c; \
})
</pre>

==Reihenfolge der Auswertung==

=Kontrollanweisungen=

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

b1= b2 && b3;

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

b1= b2 || b3;

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

b1= !b2;

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

==<tt>if</tt>-Anweisung==
Syntax: IF (Bedingung) Anweisung;
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:

[[bild:ifthenelse.png]]

Und in C schreibt man:
<pre>
if (Bedingung) // WENN
{ // DANN
Anweisung1;
}
else
{ // SONST
Anweisung2;
}
</pre>
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.

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

<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki>

<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki>

Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.
}}

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

===<tt>while</tt>-Schleife===
'''Syntax:''' while (Bedingung) { Anweisung; }

Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block!

<pre>
Zahl1=0;
while (Zahl1<3)
{
Zahl1=Zahl1+1;
Zahl2=Zahl2*2;
}
</pre>

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.
===<tt>do</tt>-<tt>while</tt>-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. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird

<pre>
unsigned char bData;
do {
bData = getch(); // Tastatureingabe (s.u.)
}while (bData != 13);
</pre>

Die Schleife wird durchlaufen und wiederholt, solange etwas anderes als 13 (<ENTER>) eingegeben wird.

===<tt>for</tt>-Schleife===
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }

Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Hat sie einen bestimmten Wert erreicht, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block

Die gesammte Schleife wird solange durchgeführt, wie die Bedingung TRUE ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.

Die Theorie ist schwer, die Praxis nicht so sehr...

<pre>
int Zaehler;
for (Zaehler = 1; Zaehler <= 10; Zaehler++)
{
Zahl2 = Zahl2 + Zaehler;
}
</pre>
Das Äquivalent als "WHILE"
<pre>
int Zaehler;
Zaehler = 1; // Anfangswerte
while (Zaehler <= 10) // Bedingung
{
Zahl2 = Zahl2 + Zaehler;
Zaehler++; // Inkrement
}
</pre>

In diesem Beispiel wird Zahl2 in jedem Schleifendurchlauf um die Zählvariable Zaehler erhöht. Da Zaehler nacheinander die Werte von 1 bis 10 hat, ist in Zahl2 nach der Schleife die Summe der Zahlen 1 bis 10 gespeichert.

'''Erklärung:'''
Zaehler=1 bedeutet, dass der Variablen Zaehler vor dem 1. Schleifendurchlauf der Wert 1 zugewiesen wird.
Zaehler<=10 ist die Schleifenbedingung; ist sie FALSE, wird die Schleife beendet.
Zaehler++ bedeutet, dass Zaehler nach jedem Durchlauf um 1 erhöht wird.

=Ein- und Ausgabe=

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

Der dazu notwendige Befehl ist printf (das f ist KEIN Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf dem Bildschirm aus (außer, Sie haben unter DOS die Standard-Ausgabe auf ein anderes Gerät, z.B. den Drucker umgeleitet, aber das ist eine andere Geschichte). Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. int, char, float, double) sein!
<pre>
#include <conio.h>
#include <stdio.h>

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

Hinweis:
Dass das Programm nach dem Compilieren und Ausführen sofort wieder beendet wird, ist nicht Ihr Fehler. Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!
Erklärung:

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

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

In der 3. Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet %c "char" (Zeichen). Es wird also %c durch 'A' ersetzt.

Die letzte Ausgabe verhält sich merkwürdig es wird doch tatsächlich eine Zahl ausgegeben, obwohl der Parameter ein Zeichen (char) ist. Aber:
%d im Text bedeutet, dass eine Zahl auszugeben ist.
ein char kann ja auch als Zahl interpretiert werden.
Es wird also 65 (der ASCII-Wert von 'A') ausgegeben. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer char Variablen!

'''Bildschirm löschen'''

Oft sind von anderen Programmen noch "Rückstände" vorhanden. Nicht nur um die zu beseitigen, brauchen Sie einen "Bildschirm-Lösch-Befehl". Dieser ist in conio.h definiert und nennt sich "clrscr" ("clear screen", deut: "lösche Bildschirm").
<pre>
#include <conio.h>
#include <stdio.h>

void main(void)
{
clrscr();
...
}
</pre>

==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.
Der wichtigste Befehl ist "scanf". Er liest Daten von der Tastatur. Die Syntax entspricht derer von printf, nur daß man außer den %c und %d keine weiteren Angaben im "Text" machen darf:

<pre>
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. Diese Zahl wird in Zahl1 abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

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

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

===getch===
getch ist eine Funktion (Siehe Kapitel Unterprogramme), die ein char-Zeichen von der Tastatur einliest. Dazu geben Sie im Programm einfach folgende Zeile an:

<pre>
char zeichen;
zeichen = getch();
</pre>
Diese Zeile erwartet die Eingabe eines char-Zeichens. Im Gegensatz zu scanf muß man nach der Eingabe des Zeichens jedoch nicht [ENTER] drücken, um die Eingabe zu bestätigen. In der Variable zeichen wird das erste Zeichen gespeichert, das auf der Tastatur eingegeben wird.

Eine weiter Möglichkeit der Anwendung von getch ist es, wenn Sie einfach "getch();" als Befehl eingeben. Dann wartet der Computer, bis Sie eine Taste drücken, speichert diese aber nicht ab.

===kbhit===
Dies ist ebenfalls eine Funktion, die eine boolschen Ausdruck zurück liefert. Sie gibt Bescheid darüber, ob eine Taste gedrückt wurde, und mit scanf oder getch abgerufen werden kann (zum Verständnis: auf der Tastatur eingegebene Zeichen werden meist nicht direkt vom Programm verarbeitet, sondern erst vom Betriebssystem bzw. dem BIOS des Computers gespeichert. Wenn das Programm nun eine Eingabe erwartet, werden die gespeicherten Zeichen "verwendet". Dies lauft jedoch so schnell ab, daß der Benutzer davon nichts merkt). Ist diese Variable TRUE, dann ist ein Zeichen abfragebereit, sonst nicht:

<pre>
while ( !kbhit() )
{
Zahl1=Zahl1+1;
printf("%d\n",Zahl1);
}
</pre>

Dieser Programmteil erhöht solange Zahl1 und gibt diese aus, bis der Benutzer eine Taste drückt.

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

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

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

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

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

void main(void)
{
int zahl1,ergebnis;

printf("Bitte Zahl eingeben: ");
scanf("%d",&zahl1);
ergebnis = hoch2(zahl1);
printf("%d hoch 2 = %d\n",zahl1,ergebnis);
printf("5 hoch 2 = %d\n",hoch2(5));
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen.
Geschachtelte-Unterprogramme wie z.B. in Pascal sind nicht möglich.
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Bei z.B. getch() ist das char. Danach folgt der Name der Funktion (case-sensitiv!). Danach kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden, und mittels Beistrich voneinander getrennt werden. Am Ende ist kein Beistrich!
Im Block der Funktion können alle Anweisungen ausgeführt werden und Variablen deklariert werden.
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung "return" und dem Rückgabewert.
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an "Variable=Funktion(Parameter);". Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

==Prozedur==
'''Syntax:''' void Name(Parameterliste);

Eine Prozedur ist nichts anderes als eine Funktion ohne Rückgabewert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede:

Als Rückgabe-Datentyp wird void angegeben.
Eine Prozedur kann daher beim Aufruf nicht einer Variablen zugewiesen werden (wie FUNCTION's) sonder wird wie eine normale Anweisung behandelt (wie z.B. printf).

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

void ausgeben(int Param1);
{
printf("Der Wert der Variablen beträgt: %d\n",Param1);
}

void main(void)
{
int Zahl1;
ausgeben(23);
Zahl1=4;
ausgeben(Zahl1);
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Durch den Befehl "ausgeben(23)" wird die Prozedur "ausgeben" mit dem Parameter 23 aufgerufen. Param1 hat also den Wert 23. Die einzige Anweisung innerhalb der Prozedur ist printf, was nun ausgeführt wird.
Danach wird mit dem nächsten Befehl innerhalb des Hauptprogrammes fortgefahren ("Zahl1=4").
Der 2. Aufruf von ausgeben erfolgt mit dem Parameter Zahl1, also wird Param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels printf ausgeben.
Unterprogramme ohne Parameter
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, z.B. main, haben statt der Parameter immer nur void stehen. Was bedeutet das? Nun ja, C erwartet, das Sie die Parameter angeben. void bedeutet "es gibt keine Parameter". "void main(void)" bedeutet also: "Erstelle ein Unterprogramm Namens main, das keinen Rückgabewert und keine Parameter hat".

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, z.B. getch, müssen Sie beim Aufruf trotzdem die Klammern angeben. Der Befehl "getch;" führt nicht getch ohne Parameter aus, sondern liefert die Adresse der Funktion getch. Alles klar? Na ja, jedenfalls: Beim Aufruf jedes Unterpgrogrammes immmer Klammern angeben.
}}

==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 1. Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Definition davor erledigt haben. Verstanden?
Um dies zu erreichen, gibt es zwei Möglichkeiten:

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

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

void ausgeben(int Zahl); //Der Prototyp

void main(void)
{
clrscr();
ausgeben(12);
getch();
}

void ausgeben(int Zahl) //Die eigentliche Prozedur
{
printf("Ausgabe: %d\n",Zahl);
}
</pre>

=Besondere Datentypen=

==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 <conio.h>
#include <stdio.h>
#include <string.h>

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

strcpy(stri1,"hallo");
clrscr();
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);
getch();
}
</pre>

'''Hinweis:'''
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, brauchen Sie kein & bei scanf angeben!

'''Erklärung:'''
Es werden 2 gleich große Strings definiert: stri1 und eingabe, mit je 20 "nutzbaren" Zeichen.
stri1 wird der Wert "hallo" zugewiesen. Das 0-Zeichen wird automatisch angefügt!
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt %s ins Spiel. Es hat die gleiche Aufgabe wie %d oder %c, nur halt für Strings.
Sie werden gebeten, eine String einzugeben.
Dieser String wird danach in die Variable stri1 kopiert.
Beide Strings (die ja nun auch den selben Wert haben) werden ausgegeben.

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

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

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

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

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

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

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

void main(void)
{
int Zahl;
printf("Zahl eingeben: ");
scanf("%d",&Zahl);
erhoehe(&Zahl);
printf("\nDie erhoehte Zahl lautet: %d\n",Zahl);
getch();
}
</pre>

==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: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
void 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>

void 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!

'''Autoren'''
* Plasma
* Bernd

'''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://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

2006-04-30T07:54:37Z

Johannuhrmann: /* Adress-Operator und Dereferenzierung */

Ein kurzer Einblick in die Programmiersprache C
=Allgemeines=
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 Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.

C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu 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.
<pre>
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

/* Anweisungen */
return 0;
}
</pre>

Die Beschreibung (die Erklärungen folgen):

;<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ücksichtige, 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 Unterprogramm main=
Unterprogramme lernen Sie zwar erst später kennen, aber dieses eine muß sein. In Gegensatz zu anderen Programmiersprachen gibt es in C kein "Hauptprogramm", sondern nur Unterprogramme. Aber woher soll der Computer wissen, welches Unterprogramm er am Beginn ausführen soll? Ganz einfach, er führt immer das Unterprogramm "main" aus. Dieses ist sozusagen 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 Integer Wert als Ergebnis zurückgeliefert. Beim [[Microcontroller]] ist main das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es dann also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß main oft als oft auch als void (Parameterfrei) definiert wird, wie oben im Beispiel zu erkennen. 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.
<pre>
/* void Definition von main ist nur beim Controller üblich
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main
* kein Fehler/Warnung erzeugt wird.
*/
void main(void)
{
}
</pre>
Was das bedeutet, lernen Sie in einem späteren Kapitel. Wichtig ist nur: ohne main ist kein Programm komplett, es lässt sich dann auch nicht ausführen!

=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":

<pre>
void main(void)
{ //der Block "main" beginnt
int Zahl;

{ //ein "namenloser" Block beginnt
//hier stehen Anweisungen
} //der "namenlose" Block endet
} //der Block "main" endet
</pre>

'''Bemerkung:'''
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, und welcher Art diese Daten sind. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können Sie alle möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können).

;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 ab!

===int, char, short, long (ganze Zahlen)===
In Variable dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, -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 recht 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>

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

=== 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 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: In Zukunft werden ich oft 1 als Synonym für "ungleich 0" verwenden. Bitte beachten Sie jedoch, das eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

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

==Zusammengesetzte Datentypen==
===Felder===
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 Felder, sogenannte ''Arrays'', zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits bekanntes Beispiel für ein Array ist ein String. Ein String ist nichts anderes als ein Array des Datentypes char.

'''Syntax:''' Datentyp Variablenname[Anzahl]

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

int main(void)
{
int Zaehler;
int Zahlen[10]; //Zahlen[0] bis Zahlen[9] !!!

for (Zaehler=0; Zaehler<10; Zaehler++)
{
printf ("Bitte Zahl %d eingeben: ", Zaehler);
scanf ("%d", & Zahlen[Zaehler]);
printf ("\n");
}
printf ("Super!\n");
for (Zaehler=0; Zaehler<10; Zaehler++)
printf ("Zahl %d war: %d\n", Zaehler, Zahlen[Zaehler]);
</pre>

'''Bemerkungen:'''
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.

{{FarbigerRahmen|
'''Merke:'''
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!
}}

===Mehrdimensionale Felder===
Manchmal benötigen 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.

==Strings (Zeichenketten)==
Bei einem String handelt es sich um ein Array, das aus einzelnen Zeichen 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.

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

<pre>
struct Person {
char vname[20], nname[20];
char telnr[15];
int alter;
};
</pre>

'''Erklärung:'''
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden 4 Variablen angelege: 3 Strings und ein <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach
struct Person Variablenname;
an.

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:
<pre>
struct Person hubert;

hubert.alter = 32;
</pre>

==Zeiger==
Jede Variable steht an einer genau definierten stelle im Speicher. Diese Stelle kann man in erfahrung bringen. Wie man das macht und was das überhaupt für Vorteile bringt, erfahren Sie in diesem Abschnitt.
Ein Zeiger ist im Prinzip eine (int-) Variable. In ihr ist jedoch keine Zahl gespeichert, sondern eine "Adresse". Diese gibt eine bestimmte Position im Arbeitsspeicher dar. Hier sehen Sie, wie man einen Zeiger definiert und mit ihm arbeitet:

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

void main(void)
{
int Zahl;
int *Zeiger;

Zeiger=&Zahl;
*Zeiger=12;

printf("%d = %d", Zahl, *Zeiger);
</pre>

'''Erklärung:'''
Um einen Zeiger anzulegen, gibt man folgendes an: Datentyp, dann einen Stern (*), anschließend den Namen (und einen Strichpunkt).
Um einen Zeiger auf eine bestimmte Zahl "zeigen" zu lassen, muß man dem Zeiger die Adresse einer Variablen zuordnen. Das funktioniert mittels dem Adress-Operator & (Zeiger=&Zahl).
Jetzt möchten Sie dem Zeiger einen Wert zuweisen. Aber natürlich nicht dem Zeiger, sondern der Variablen, auf die der Zeiger "zeigt". Na, "Zahl=Wert;", werden Sie sagen. Aber wozu dann Zeiger? Na, ja, jednefalls geht das mittels des "Inhalts-Operators" * (*Zeiger=12).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an printf (und jedes andere Unterprogramm) übergeben.

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

Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.
==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!
<pre>
int Zahl1, Zahl2;
char Zeichen;

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

return 0;
}
</pre>
;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 Zahl1 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 int und char dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable FALSE, ansonsten ist Sie TRUE.
intVariable = !0; // entspricht TRUE
intVariable = 0; // entspricht FALSE

==Vergleich von Variablen==
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln:
<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>
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl.
intVariable = Zahl1 <= Zahl2;
das komplette Beispiel zeigt es deutlicher:
<pre>
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */

printf ("Ergebnis: %d\n", i);
</pre>
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").

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

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

==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>: 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.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert.
Eine Variable ist so ein LValue, der etwas zugewiesen werden kann:
a = 1;
Hingegen ist <tt>a+1</tt> kein LValue, denn eine Zuweisung wie
a+1 = 2;
erzeugt einen Compilerfehler, der etwas lautet könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

==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 Eigenheit der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet.

Beispiel:
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */

<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,
die eine aufwändige Operation durchführt.
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.

Wo ist also der Unterschied? 
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.

==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==
==Komponenten-Auswahl bei Structs und Unions==
==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:
<pre>
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */

/* z ist ein Zeiger auf eine Integervariable und enthält somit
die Speicheradresse einer Integervariablen
*/
int *z;

/* Verwendung des Adressoperators... */
z = &x; /* weise z die Speicheradresse von x zu */

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

/* da z auf x zeigt, hat auch x jetzt den Wert 6 */
</pre>

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

Statt
(*strukturZeiger).element
kann geschrieben werden
strukturZeiger->element
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

{{FarbigerRahmen |
'''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:

<pre>
int *z; /* z ist ein Zeiger auf einen Integer */

/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.
z enthält irgendeine(!) Adresse
*/

/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */
*z = *z + 1;
</pre>

Viele C-Compiler (z.B. gcc) 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.

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

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingte Zuweisung===
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;

==Blöcke==
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks.
Der Block muss un runden Klammern stehen:
int sum;
sum = ({
int i, s = 0;
for (i=1; i<= 100; i++)
s += i;
s;
});

Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc,
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer
Instruktion nicht machbar wäre:
<pre>
#define PSTR(s) \
({ \
static char __c[] PROGMEM = (s); \
__c; \
})
</pre>

==Reihenfolge der Auswertung==

=Kontrollanweisungen=

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

b1= b2 && b3;

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

b1= b2 || b3;

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

b1= !b2;

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

==<tt>if</tt>-Anweisung==
Syntax: IF (Bedingung) Anweisung;
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:

[[bild:ifthenelse.png]]

Und in C schreibt man:
<pre>
if (Bedingung) // WENN
{ // DANN
Anweisung1;
}
else
{ // SONST
Anweisung2;
}
</pre>
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.

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

<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki>

<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki>

Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.
}}

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

===<tt>while</tt>-Schleife===
'''Syntax:''' while (Bedingung) { Anweisung; }

Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block!

<pre>
Zahl1=0;
while (Zahl1<3)
{
Zahl1=Zahl1+1;
Zahl2=Zahl2*2;
}
</pre>

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.
===<tt>do</tt>-<tt>while</tt>-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. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird

<pre>
unsigned char bData;
do {
bData = getch(); // Tastatureingabe (s.u.)
}while (bData != 13);
</pre>

Die Schleife wird durchlaufen und wiederholt, solange etwas anderes als 13 (<ENTER>) eingegeben wird.

===<tt>for</tt>-Schleife===
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }

Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Hat sie einen bestimmten Wert erreicht, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block

Die gesammte Schleife wird solange durchgeführt, wie die Bedingung TRUE ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.

Die Theorie ist schwer, die Praxis nicht so sehr...

<pre>
int Zaehler;
for (Zaehler = 1; Zaehler <= 10; Zaehler++)
{
Zahl2 = Zahl2 + Zaehler;
}
</pre>
Das Äquivalent als "WHILE"
<pre>
int Zaehler;
Zaehler = 1; // Anfangswerte
while (Zaehler <= 10) // Bedingung
{
Zahl2 = Zahl2 + Zaehler;
Zaehler++; // Inkrement
}
</pre>

In diesem Beispiel wird Zahl2 in jedem Schleifendurchlauf um die Zählvariable Zaehler erhöht. Da Zaehler nacheinander die Werte von 1 bis 10 hat, ist in Zahl2 nach der Schleife die Summe der Zahlen 1 bis 10 gespeichert.

'''Erklärung:'''
Zaehler=1 bedeutet, dass der Variablen Zaehler vor dem 1. Schleifendurchlauf der Wert 1 zugewiesen wird.
Zaehler<=10 ist die Schleifenbedingung; ist sie FALSE, wird die Schleife beendet.
Zaehler++ bedeutet, dass Zaehler nach jedem Durchlauf um 1 erhöht wird.

=Ein- und Ausgabe=

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

Der dazu notwendige Befehl ist printf (das f ist KEIN Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf dem Bildschirm aus (außer, Sie haben unter DOS die Standard-Ausgabe auf ein anderes Gerät, z.B. den Drucker umgeleitet, aber das ist eine andere Geschichte). Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. int, char, float, double) sein!
<pre>
#include <conio.h>
#include <stdio.h>

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

Hinweis:
Dass das Programm nach dem Compilieren und Ausführen sofort wieder beendet wird, ist nicht Ihr Fehler. Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!
Erklärung:

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

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

In der 3. Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet %c "char" (Zeichen). Es wird also %c durch 'A' ersetzt.

Die letzte Ausgabe verhält sich merkwürdig es wird doch tatsächlich eine Zahl ausgegeben, obwohl der Parameter ein Zeichen (char) ist. Aber:
%d im Text bedeutet, dass eine Zahl auszugeben ist.
ein char kann ja auch als Zahl interpretiert werden.
Es wird also 65 (der ASCII-Wert von 'A') ausgegeben. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer char Variablen!

'''Bildschirm löschen'''

Oft sind von anderen Programmen noch "Rückstände" vorhanden. Nicht nur um die zu beseitigen, brauchen Sie einen "Bildschirm-Lösch-Befehl". Dieser ist in conio.h definiert und nennt sich "clrscr" ("clear screen", deut: "lösche Bildschirm").
<pre>
#include <conio.h>
#include <stdio.h>

void main(void)
{
clrscr();
...
}
</pre>

==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.
Der wichtigste Befehl ist "scanf". Er liest Daten von der Tastatur. Die Syntax entspricht derer von printf, nur daß man außer den %c und %d keine weiteren Angaben im "Text" machen darf:

<pre>
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. Diese Zahl wird in Zahl1 abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

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

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

===getch===
getch ist eine Funktion (Siehe Kapitel Unterprogramme), die ein char-Zeichen von der Tastatur einliest. Dazu geben Sie im Programm einfach folgende Zeile an:

<pre>
char zeichen;
zeichen = getch();
</pre>
Diese Zeile erwartet die Eingabe eines char-Zeichens. Im Gegensatz zu scanf muß man nach der Eingabe des Zeichens jedoch nicht [ENTER] drücken, um die Eingabe zu bestätigen. In der Variable zeichen wird das erste Zeichen gespeichert, das auf der Tastatur eingegeben wird.

Eine weiter Möglichkeit der Anwendung von getch ist es, wenn Sie einfach "getch();" als Befehl eingeben. Dann wartet der Computer, bis Sie eine Taste drücken, speichert diese aber nicht ab.

===kbhit===
Dies ist ebenfalls eine Funktion, die eine boolschen Ausdruck zurück liefert. Sie gibt Bescheid darüber, ob eine Taste gedrückt wurde, und mit scanf oder getch abgerufen werden kann (zum Verständnis: auf der Tastatur eingegebene Zeichen werden meist nicht direkt vom Programm verarbeitet, sondern erst vom Betriebssystem bzw. dem BIOS des Computers gespeichert. Wenn das Programm nun eine Eingabe erwartet, werden die gespeicherten Zeichen "verwendet". Dies lauft jedoch so schnell ab, daß der Benutzer davon nichts merkt). Ist diese Variable TRUE, dann ist ein Zeichen abfragebereit, sonst nicht:

<pre>
while ( !kbhit() )
{
Zahl1=Zahl1+1;
printf("%d\n",Zahl1);
}
</pre>

Dieser Programmteil erhöht solange Zahl1 und gibt diese aus, bis der Benutzer eine Taste drückt.

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

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

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

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

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

void main(void)
{
int zahl1,ergebnis;

printf("Bitte Zahl eingeben: ");
scanf("%d",&zahl1);
ergebnis = hoch2(zahl1);
printf("%d hoch 2 = %d\n",zahl1,ergebnis);
printf("5 hoch 2 = %d\n",hoch2(5));
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen.
Geschachtelte-Unterprogramme wie z.B. in Pascal sind nicht möglich.
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Bei z.B. getch() ist das char. Danach folgt der Name der Funktion (case-sensitiv!). Danach kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden, und mittels Beistrich voneinander getrennt werden. Am Ende ist kein Beistrich!
Im Block der Funktion können alle Anweisungen ausgeführt werden und Variablen deklariert werden.
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung "return" und dem Rückgabewert.
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an "Variable=Funktion(Parameter);". Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

==Prozedur==
'''Syntax:''' void Name(Parameterliste);

Eine Prozedur ist nichts anderes als eine Funktion ohne Rückgabewert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede:

Als Rückgabe-Datentyp wird void angegeben.
Eine Prozedur kann daher beim Aufruf nicht einer Variablen zugewiesen werden (wie FUNCTION's) sonder wird wie eine normale Anweisung behandelt (wie z.B. printf).

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

void ausgeben(int Param1);
{
printf("Der Wert der Variablen beträgt: %d\n",Param1);
}

void main(void)
{
int Zahl1;
ausgeben(23);
Zahl1=4;
ausgeben(Zahl1);
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Durch den Befehl "ausgeben(23)" wird die Prozedur "ausgeben" mit dem Parameter 23 aufgerufen. Param1 hat also den Wert 23. Die einzige Anweisung innerhalb der Prozedur ist printf, was nun ausgeführt wird.
Danach wird mit dem nächsten Befehl innerhalb des Hauptprogrammes fortgefahren ("Zahl1=4").
Der 2. Aufruf von ausgeben erfolgt mit dem Parameter Zahl1, also wird Param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels printf ausgeben.
Unterprogramme ohne Parameter
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, z.B. main, haben statt der Parameter immer nur void stehen. Was bedeutet das? Nun ja, C erwartet, das Sie die Parameter angeben. void bedeutet "es gibt keine Parameter". "void main(void)" bedeutet also: "Erstelle ein Unterprogramm Namens main, das keinen Rückgabewert und keine Parameter hat".

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, z.B. getch, müssen Sie beim Aufruf trotzdem die Klammern angeben. Der Befehl "getch;" führt nicht getch ohne Parameter aus, sondern liefert die Adresse der Funktion getch. Alles klar? Na ja, jedenfalls: Beim Aufruf jedes Unterpgrogrammes immmer Klammern angeben.
}}

==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 1. Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Definition davor erledigt haben. Verstanden?
Um dies zu erreichen, gibt es zwei Möglichkeiten:

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

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

void ausgeben(int Zahl); //Der Prototyp

void main(void)
{
clrscr();
ausgeben(12);
getch();
}

void ausgeben(int Zahl) //Die eigentliche Prozedur
{
printf("Ausgabe: %d\n",Zahl);
}
</pre>

=Besondere Datentypen=

==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 <conio.h>
#include <stdio.h>
#include <string.h>

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

strcpy(stri1,"hallo");
clrscr();
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);
getch();
}
</pre>

'''Hinweis:'''
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, brauchen Sie kein & bei scanf angeben!

'''Erklärung:'''
Es werden 2 gleich große Strings definiert: stri1 und eingabe, mit je 20 "nutzbaren" Zeichen.
stri1 wird der Wert "hallo" zugewiesen. Das 0-Zeichen wird automatisch angefügt!
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt %s ins Spiel. Es hat die gleiche Aufgabe wie %d oder %c, nur halt für Strings.
Sie werden gebeten, eine String einzugeben.
Dieser String wird danach in die Variable stri1 kopiert.
Beide Strings (die ja nun auch den selben Wert haben) werden ausgegeben.

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

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

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

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

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

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

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

void main(void)
{
int Zahl;
printf("Zahl eingeben: ");
scanf("%d",&Zahl);
erhoehe(&Zahl);
printf("\nDie erhoehte Zahl lautet: %d\n",Zahl);
getch();
}
</pre>

==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: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
void 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>

void 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!

'''Autoren'''
* Plasma
* Bernd

'''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://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

2006-04-28T14:26:12Z

Johannuhrmann: /* Adress-Operator und Dereferenzierung */

Ein kurzer Einblick in die Programmiersprache C
=Allgemeines=
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 Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.

C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu 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.
<pre>
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

/* Anweisungen */
return 0;
}
</pre>

Die Beschreibung (die Erklärungen folgen):

;<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ücksichtige, 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 Unterprogramm main=
Unterprogramme lernen Sie zwar erst später kennen, aber dieses eine muß sein. In Gegensatz zu anderen Programmiersprachen gibt es in C kein "Hauptprogramm", sondern nur Unterprogramme. Aber woher soll der Computer wissen, welches Unterprogramm er am Beginn ausführen soll? Ganz einfach, er führt immer das Unterprogramm "main" aus. Dieses ist sozusagen 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 Integer Wert als Ergebnis zurückgeliefert. Beim [[Microcontroller]] ist main das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es dann also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß main oft als oft auch als void (Parameterfrei) definiert wird, wie oben im Beispiel zu erkennen. 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.
<pre>
/* void Definition von main ist nur beim Controller üblich
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main
* kein Fehler/Warnung erzeugt wird.
*/
void main(void)
{
}
</pre>
Was das bedeutet, lernen Sie in einem späteren Kapitel. Wichtig ist nur: ohne main ist kein Programm komplett, es lässt sich dann auch nicht ausführen!

=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":

<pre>
void main(void)
{ //der Block "main" beginnt
int Zahl;

{ //ein "namenloser" Block beginnt
//hier stehen Anweisungen
} //der "namenlose" Block endet
} //der Block "main" endet
</pre>

'''Bemerkung:'''
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, und welcher Art diese Daten sind. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können Sie alle möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können).

;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 ab!

===int, char, short, long (ganze Zahlen)===
In Variable dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, -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 recht 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>

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

=== 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 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: In Zukunft werden ich oft 1 als Synonym für "ungleich 0" verwenden. Bitte beachten Sie jedoch, das eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

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

==Zusammengesetzte Datentypen==
===Felder===
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 Felder, sogenannte ''Arrays'', zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits bekanntes Beispiel für ein Array ist ein String. Ein String ist nichts anderes als ein Array des Datentypes char.

'''Syntax:''' Datentyp Variablenname[Anzahl]

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

int main(void)
{
int Zaehler;
int Zahlen[10]; //Zahlen[0] bis Zahlen[9] !!!

for (Zaehler=0; Zaehler<10; Zaehler++)
{
printf ("Bitte Zahl %d eingeben: ", Zaehler);
scanf ("%d", & Zahlen[Zaehler]);
printf ("\n");
}
printf ("Super!\n");
for (Zaehler=0; Zaehler<10; Zaehler++)
printf ("Zahl %d war: %d\n", Zaehler, Zahlen[Zaehler]);
</pre>

'''Bemerkungen:'''
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.

{{FarbigerRahmen|
'''Merke:'''
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!
}}

===Mehrdimensionale Felder===
Manchmal benötigen 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.

==Strings (Zeichenketten)==
Bei einem String handelt es sich um ein Array, das aus einzelnen Zeichen 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.

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

<pre>
struct Person {
char vname[20], nname[20];
char telnr[15];
int alter;
};
</pre>

'''Erklärung:'''
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden 4 Variablen angelege: 3 Strings und ein <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach
struct Person Variablenname;
an.

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:
<pre>
struct Person hubert;

hubert.alter = 32;
</pre>

==Zeiger==
Jede Variable steht an einer genau definierten stelle im Speicher. Diese Stelle kann man in erfahrung bringen. Wie man das macht und was das überhaupt für Vorteile bringt, erfahren Sie in diesem Abschnitt.
Ein Zeiger ist im Prinzip eine (int-) Variable. In ihr ist jedoch keine Zahl gespeichert, sondern eine "Adresse". Diese gibt eine bestimmte Position im Arbeitsspeicher dar. Hier sehen Sie, wie man einen Zeiger definiert und mit ihm arbeitet:

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

void main(void)
{
int Zahl;
int *Zeiger;

Zeiger=&Zahl;
*Zeiger=12;

printf("%d = %d", Zahl, *Zeiger);
</pre>

'''Erklärung:'''
Um einen Zeiger anzulegen, gibt man folgendes an: Datentyp, dann einen Stern (*), anschließend den Namen (und einen Strichpunkt).
Um einen Zeiger auf eine bestimmte Zahl "zeigen" zu lassen, muß man dem Zeiger die Adresse einer Variablen zuordnen. Das funktioniert mittels dem Adress-Operator & (Zeiger=&Zahl).
Jetzt möchten Sie dem Zeiger einen Wert zuweisen. Aber natürlich nicht dem Zeiger, sondern der Variablen, auf die der Zeiger "zeigt". Na, "Zahl=Wert;", werden Sie sagen. Aber wozu dann Zeiger? Na, ja, jednefalls geht das mittels des "Inhalts-Operators" * (*Zeiger=12).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an printf (und jedes andere Unterprogramm) übergeben.

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

Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.
==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!
<pre>
int Zahl1, Zahl2;
char Zeichen;

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

return 0;
}
</pre>
;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 Zahl1 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 int und char dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable FALSE, ansonsten ist Sie TRUE.
intVariable = !0; // entspricht TRUE
intVariable = 0; // entspricht FALSE

==Vergleich von Variablen==
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln:
<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>
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl.
intVariable = Zahl1 <= Zahl2;
das komplette Beispiel zeigt es deutlicher:
<pre>
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */

printf ("Ergebnis: %d\n", i);
</pre>
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").

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

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

==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>: 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.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert.
Eine Variable ist so ein LValue, der etwas zugewiesen werden kann:
a = 1;
Hingegen ist <tt>a+1</tt> kein LValue, denn eine Zuweisung wie
a+1 = 2;
erzeugt einen Compilerfehler, der etwas lautet könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

==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 Eigenheit der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet.

Beispiel:
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */

<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,
die eine aufwändige Operation durchführt.
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.

Wo ist also der Unterschied? 
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.

==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==
==Komponenten-Auswahl bei Structs und Unions==
==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
|}
</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:
<pre>
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */

/* z ist ein Zeiger auf eine Integervariable und enthält somit
die Speicheradresse einer Integervariablen
*/
int *z;

/* Verwendung des Adressoperators... */
z = &x; /* weise z die Speicheradresse von x zu */

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

/* da z auf x zeigt, hat auch x jetzt den Wert 6 */
</pre>

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

Statt
(*strukturZeiger).element
kann geschrieben werden
strukturZeiger->element
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

{{FarbigerRahmen |
'''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:

<pre>
int *z; /* z ist ein Zeiger auf einen Integer */

/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.
z enthält irgendeine(!) Adresse
*/

/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */
*z = *z + 1;
</pre>

Viele C-Compiler (z.B. gcc) 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.

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

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingte Zuweisung===
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;

==Blöcke==
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks.
Der Block muss un runden Klammern stehen:
int sum;
sum = ({
int i, s = 0;
for (i=1; i<= 100; i++)
s += i;
s;
});

Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc,
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer
Instruktion nicht machbar wäre:
<pre>
#define PSTR(s) \
({ \
static char __c[] PROGMEM = (s); \
__c; \
})
</pre>

==Reihenfolge der Auswertung==

=Kontrollanweisungen=

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

b1= b2 && b3;

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

b1= b2 || b3;

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

b1= !b2;

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

==<tt>if</tt>-Anweisung==
Syntax: IF (Bedingung) Anweisung;
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:

[[bild:ifthenelse.png]]

Und in C schreibt man:
<pre>
if (Bedingung) // WENN
{ // DANN
Anweisung1;
}
else
{ // SONST
Anweisung2;
}
</pre>
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.

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

<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki>

<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki>

Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.
}}

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

===<tt>while</tt>-Schleife===
'''Syntax:''' while (Bedingung) { Anweisung; }

Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block!

<pre>
Zahl1=0;
while (Zahl1<3)
{
Zahl1=Zahl1+1;
Zahl2=Zahl2*2;
}
</pre>

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.
===<tt>do</tt>-<tt>while</tt>-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. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird

<pre>
unsigned char bData;
do {
bData = getch(); // Tastatureingabe (s.u.)
}while (bData != 13);
</pre>

Die Schleife wird durchlaufen und wiederholt, solange etwas anderes als 13 (<ENTER>) eingegeben wird.

===<tt>for</tt>-Schleife===
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }

Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Hat sie einen bestimmten Wert erreicht, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block

Die gesammte Schleife wird solange durchgeführt, wie die Bedingung TRUE ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.

Die Theorie ist schwer, die Praxis nicht so sehr...

<pre>
int Zaehler;
for (Zaehler = 1; Zaehler <= 10; Zaehler++)
{
Zahl2 = Zahl2 + Zaehler;
}
</pre>
Das Äquivalent als "WHILE"
<pre>
int Zaehler;
Zaehler = 1; // Anfangswerte
while (Zaehler <= 10) // Bedingung
{
Zahl2 = Zahl2 + Zaehler;
Zaehler++; // Inkrement
}
</pre>

In diesem Beispiel wird Zahl2 in jedem Schleifendurchlauf um die Zählvariable Zaehler erhöht. Da Zaehler nacheinander die Werte von 1 bis 10 hat, ist in Zahl2 nach der Schleife die Summe der Zahlen 1 bis 10 gespeichert.

'''Erklärung:'''
Zaehler=1 bedeutet, dass der Variablen Zaehler vor dem 1. Schleifendurchlauf der Wert 1 zugewiesen wird.
Zaehler<=10 ist die Schleifenbedingung; ist sie FALSE, wird die Schleife beendet.
Zaehler++ bedeutet, dass Zaehler nach jedem Durchlauf um 1 erhöht wird.

=Ein- und Ausgabe=

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

Der dazu notwendige Befehl ist printf (das f ist KEIN Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf dem Bildschirm aus (außer, Sie haben unter DOS die Standard-Ausgabe auf ein anderes Gerät, z.B. den Drucker umgeleitet, aber das ist eine andere Geschichte). Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. int, char, float, double) sein!
<pre>
#include <conio.h>
#include <stdio.h>

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

Hinweis:
Dass das Programm nach dem Compilieren und Ausführen sofort wieder beendet wird, ist nicht Ihr Fehler. Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!
Erklärung:

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

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

In der 3. Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet %c "char" (Zeichen). Es wird also %c durch 'A' ersetzt.

Die letzte Ausgabe verhält sich merkwürdig es wird doch tatsächlich eine Zahl ausgegeben, obwohl der Parameter ein Zeichen (char) ist. Aber:
%d im Text bedeutet, dass eine Zahl auszugeben ist.
ein char kann ja auch als Zahl interpretiert werden.
Es wird also 65 (der ASCII-Wert von 'A') ausgegeben. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer char Variablen!

'''Bildschirm löschen'''

Oft sind von anderen Programmen noch "Rückstände" vorhanden. Nicht nur um die zu beseitigen, brauchen Sie einen "Bildschirm-Lösch-Befehl". Dieser ist in conio.h definiert und nennt sich "clrscr" ("clear screen", deut: "lösche Bildschirm").
<pre>
#include <conio.h>
#include <stdio.h>

void main(void)
{
clrscr();
...
}
</pre>

==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.
Der wichtigste Befehl ist "scanf". Er liest Daten von der Tastatur. Die Syntax entspricht derer von printf, nur daß man außer den %c und %d keine weiteren Angaben im "Text" machen darf:

<pre>
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. Diese Zahl wird in Zahl1 abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

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

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

===getch===
getch ist eine Funktion (Siehe Kapitel Unterprogramme), die ein char-Zeichen von der Tastatur einliest. Dazu geben Sie im Programm einfach folgende Zeile an:

<pre>
char zeichen;
zeichen = getch();
</pre>
Diese Zeile erwartet die Eingabe eines char-Zeichens. Im Gegensatz zu scanf muß man nach der Eingabe des Zeichens jedoch nicht [ENTER] drücken, um die Eingabe zu bestätigen. In der Variable zeichen wird das erste Zeichen gespeichert, das auf der Tastatur eingegeben wird.

Eine weiter Möglichkeit der Anwendung von getch ist es, wenn Sie einfach "getch();" als Befehl eingeben. Dann wartet der Computer, bis Sie eine Taste drücken, speichert diese aber nicht ab.

===kbhit===
Dies ist ebenfalls eine Funktion, die eine boolschen Ausdruck zurück liefert. Sie gibt Bescheid darüber, ob eine Taste gedrückt wurde, und mit scanf oder getch abgerufen werden kann (zum Verständnis: auf der Tastatur eingegebene Zeichen werden meist nicht direkt vom Programm verarbeitet, sondern erst vom Betriebssystem bzw. dem BIOS des Computers gespeichert. Wenn das Programm nun eine Eingabe erwartet, werden die gespeicherten Zeichen "verwendet". Dies lauft jedoch so schnell ab, daß der Benutzer davon nichts merkt). Ist diese Variable TRUE, dann ist ein Zeichen abfragebereit, sonst nicht:

<pre>
while ( !kbhit() )
{
Zahl1=Zahl1+1;
printf("%d\n",Zahl1);
}
</pre>

Dieser Programmteil erhöht solange Zahl1 und gibt diese aus, bis der Benutzer eine Taste drückt.

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

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

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

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

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

void main(void)
{
int zahl1,ergebnis;

printf("Bitte Zahl eingeben: ");
scanf("%d",&zahl1);
ergebnis = hoch2(zahl1);
printf("%d hoch 2 = %d\n",zahl1,ergebnis);
printf("5 hoch 2 = %d\n",hoch2(5));
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen.
Geschachtelte-Unterprogramme wie z.B. in Pascal sind nicht möglich.
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Bei z.B. getch() ist das char. Danach folgt der Name der Funktion (case-sensitiv!). Danach kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden, und mittels Beistrich voneinander getrennt werden. Am Ende ist kein Beistrich!
Im Block der Funktion können alle Anweisungen ausgeführt werden und Variablen deklariert werden.
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung "return" und dem Rückgabewert.
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an "Variable=Funktion(Parameter);". Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

==Prozedur==
'''Syntax:''' void Name(Parameterliste);

Eine Prozedur ist nichts anderes als eine Funktion ohne Rückgabewert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede:

Als Rückgabe-Datentyp wird void angegeben.
Eine Prozedur kann daher beim Aufruf nicht einer Variablen zugewiesen werden (wie FUNCTION's) sonder wird wie eine normale Anweisung behandelt (wie z.B. printf).

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

void ausgeben(int Param1);
{
printf("Der Wert der Variablen beträgt: %d\n",Param1);
}

void main(void)
{
int Zahl1;
ausgeben(23);
Zahl1=4;
ausgeben(Zahl1);
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Durch den Befehl "ausgeben(23)" wird die Prozedur "ausgeben" mit dem Parameter 23 aufgerufen. Param1 hat also den Wert 23. Die einzige Anweisung innerhalb der Prozedur ist printf, was nun ausgeführt wird.
Danach wird mit dem nächsten Befehl innerhalb des Hauptprogrammes fortgefahren ("Zahl1=4").
Der 2. Aufruf von ausgeben erfolgt mit dem Parameter Zahl1, also wird Param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels printf ausgeben.
Unterprogramme ohne Parameter
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, z.B. main, haben statt der Parameter immer nur void stehen. Was bedeutet das? Nun ja, C erwartet, das Sie die Parameter angeben. void bedeutet "es gibt keine Parameter". "void main(void)" bedeutet also: "Erstelle ein Unterprogramm Namens main, das keinen Rückgabewert und keine Parameter hat".

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, z.B. getch, müssen Sie beim Aufruf trotzdem die Klammern angeben. Der Befehl "getch;" führt nicht getch ohne Parameter aus, sondern liefert die Adresse der Funktion getch. Alles klar? Na ja, jedenfalls: Beim Aufruf jedes Unterpgrogrammes immmer Klammern angeben.
}}

==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 1. Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Definition davor erledigt haben. Verstanden?
Um dies zu erreichen, gibt es zwei Möglichkeiten:

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

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

void ausgeben(int Zahl); //Der Prototyp

void main(void)
{
clrscr();
ausgeben(12);
getch();
}

void ausgeben(int Zahl) //Die eigentliche Prozedur
{
printf("Ausgabe: %d\n",Zahl);
}
</pre>

=Besondere Datentypen=

==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 <conio.h>
#include <stdio.h>
#include <string.h>

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

strcpy(stri1,"hallo");
clrscr();
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);
getch();
}
</pre>

'''Hinweis:'''
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, brauchen Sie kein & bei scanf angeben!

'''Erklärung:'''
Es werden 2 gleich große Strings definiert: stri1 und eingabe, mit je 20 "nutzbaren" Zeichen.
stri1 wird der Wert "hallo" zugewiesen. Das 0-Zeichen wird automatisch angefügt!
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt %s ins Spiel. Es hat die gleiche Aufgabe wie %d oder %c, nur halt für Strings.
Sie werden gebeten, eine String einzugeben.
Dieser String wird danach in die Variable stri1 kopiert.
Beide Strings (die ja nun auch den selben Wert haben) werden ausgegeben.

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

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

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

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

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

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

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

void main(void)
{
int Zahl;
printf("Zahl eingeben: ");
scanf("%d",&Zahl);
erhoehe(&Zahl);
printf("\nDie erhoehte Zahl lautet: %d\n",Zahl);
getch();
}
</pre>

==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: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
void 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>

void 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!

'''Autoren'''
* Plasma
* Bernd

'''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://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

2006-04-28T05:54:39Z

Johannuhrmann: /* Adress-Operator und Dereferenzierung */

Ein kurzer Einblick in die Programmiersprache C
=Allgemeines=
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 Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.

C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu 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.
<pre>
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

/* Anweisungen */
return 0;
}
</pre>

Die Beschreibung (die Erklärungen folgen):

;<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ücksichtige, 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 Unterprogramm main=
Unterprogramme lernen Sie zwar erst später kennen, aber dieses eine muß sein. In Gegensatz zu anderen Programmiersprachen gibt es in C kein "Hauptprogramm", sondern nur Unterprogramme. Aber woher soll der Computer wissen, welches Unterprogramm er am Beginn ausführen soll? Ganz einfach, er führt immer das Unterprogramm "main" aus. Dieses ist sozusagen 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 Integer Wert als Ergebnis zurückgeliefert. Beim [[Microcontroller]] ist main das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es dann also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß main oft als oft auch als void (Parameterfrei) definiert wird, wie oben im Beispiel zu erkennen. 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.
<pre>
/* void Definition von main ist nur beim Controller üblich
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main
* kein Fehler/Warnung erzeugt wird.
*/
void main(void)
{
}
</pre>
Was das bedeutet, lernen Sie in einem späteren Kapitel. Wichtig ist nur: ohne main ist kein Programm komplett, es lässt sich dann auch nicht ausführen!

=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":

<pre>
void main(void)
{ //der Block "main" beginnt
int Zahl;

{ //ein "namenloser" Block beginnt
//hier stehen Anweisungen
} //der "namenlose" Block endet
} //der Block "main" endet
</pre>

'''Bemerkung:'''
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, und welcher Art diese Daten sind. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können Sie alle möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können).

;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 ab!

===int, char, short, long (ganze Zahlen)===
In Variable dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, -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 recht 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>

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

=== 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 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: In Zukunft werden ich oft 1 als Synonym für "ungleich 0" verwenden. Bitte beachten Sie jedoch, das eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

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

==Zusammengesetzte Datentypen==
===Felder===
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 Felder, sogenannte ''Arrays'', zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits bekanntes Beispiel für ein Array ist ein String. Ein String ist nichts anderes als ein Array des Datentypes char.

'''Syntax:''' Datentyp Variablenname[Anzahl]

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

int main(void)
{
int Zaehler;
int Zahlen[10]; //Zahlen[0] bis Zahlen[9] !!!

for (Zaehler=0; Zaehler<10; Zaehler++)
{
printf ("Bitte Zahl %d eingeben: ", Zaehler);
scanf ("%d", & Zahlen[Zaehler]);
printf ("\n");
}
printf ("Super!\n");
for (Zaehler=0; Zaehler<10; Zaehler++)
printf ("Zahl %d war: %d\n", Zaehler, Zahlen[Zaehler]);
</pre>

'''Bemerkungen:'''
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.

{{FarbigerRahmen|
'''Merke:'''
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!
}}

===Mehrdimensionale Felder===
Manchmal benötigen 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.

==Strings (Zeichenketten)==
Bei einem String handelt es sich um ein Array, das aus einzelnen Zeichen 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.

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

<pre>
struct Person {
char vname[20], nname[20];
char telnr[15];
int alter;
};
</pre>

'''Erklärung:'''
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden 4 Variablen angelege: 3 Strings und ein <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach
struct Person Variablenname;
an.

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:
<pre>
struct Person hubert;

hubert.alter = 32;
</pre>

==Zeiger==
Jede Variable steht an einer genau definierten stelle im Speicher. Diese Stelle kann man in erfahrung bringen. Wie man das macht und was das überhaupt für Vorteile bringt, erfahren Sie in diesem Abschnitt.
Ein Zeiger ist im Prinzip eine (int-) Variable. In ihr ist jedoch keine Zahl gespeichert, sondern eine "Adresse". Diese gibt eine bestimmte Position im Arbeitsspeicher dar. Hier sehen Sie, wie man einen Zeiger definiert und mit ihm arbeitet:

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

void main(void)
{
int Zahl;
int *Zeiger;

Zeiger=&Zahl;
*Zeiger=12;

printf("%d = %d", Zahl, *Zeiger);
</pre>

'''Erklärung:'''
Um einen Zeiger anzulegen, gibt man folgendes an: Datentyp, dann einen Stern (*), anschließend den Namen (und einen Strichpunkt).
Um einen Zeiger auf eine bestimmte Zahl "zeigen" zu lassen, muß man dem Zeiger die Adresse einer Variablen zuordnen. Das funktioniert mittels dem Adress-Operator & (Zeiger=&Zahl).
Jetzt möchten Sie dem Zeiger einen Wert zuweisen. Aber natürlich nicht dem Zeiger, sondern der Variablen, auf die der Zeiger "zeigt". Na, "Zahl=Wert;", werden Sie sagen. Aber wozu dann Zeiger? Na, ja, jednefalls geht das mittels des "Inhalts-Operators" * (*Zeiger=12).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an printf (und jedes andere Unterprogramm) übergeben.

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

Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.
==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!
<pre>
int Zahl1, Zahl2;
char Zeichen;

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

return 0;
}
</pre>
;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 Zahl1 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 int und char dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable FALSE, ansonsten ist Sie TRUE.
intVariable = !0; // entspricht TRUE
intVariable = 0; // entspricht FALSE

==Vergleich von Variablen==
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln:
<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>
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl.
intVariable = Zahl1 <= Zahl2;
das komplette Beispiel zeigt es deutlicher:
<pre>
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */

printf ("Ergebnis: %d\n", i);
</pre>
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").

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

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

==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>: 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.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert.
Eine Variable ist so ein LValue, der etwas zugewiesen werden kann:
a = 1;
Hingegen ist <tt>a+1</tt> kein LValue, denn eine Zuweisung wie
a+1 = 2;
erzeugt einen Compilerfehler, der etwas lautet könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

==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 Eigenheit der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet.

Beispiel:
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */

<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,
die eine aufwändige Operation durchführt.
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.

Wo ist also der Unterschied? 
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.

==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==
==Komponenten-Auswahl bei Structs und Unions==
==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
|}
</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:
<pre>
int x = 5; /* x ist eine Integervariable und hat den Wert 5 */

/* z ist ein Zeiger auf eine Integervariable und enthält somit
die Speicheradresse eine Integervariablen
*/
int *z;

/* Verwendung des Adressoperators... */
z = &x; /* weise z die Speicheradresse von x zu */

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

/* da z auf x zeigt, hat auch x jetzt den Wert 6 */
</pre>

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

Statt
(*strukturZeiger).element
kann geschrieben werden
strukturZeiger->element
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

{{FarbigerRahmen |
'''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:

<pre>
int *z; /* z ist ein Zeiger auf einen Integer */

/* An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.
z enthält irgendeine(!) Adresse
*/

/* "Erhöhe einen Integer irgendwo im Speicher um 1" -> CRASH */
*z = *z + 1;
</pre>

Viele C-Compiler (z.B. gcc) 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.

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

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingte Zuweisung===
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;

==Blöcke==
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks.
Der Block muss un runden Klammern stehen:
int sum;
sum = ({
int i, s = 0;
for (i=1; i<= 100; i++)
s += i;
s;
});

Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc,
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer
Instruktion nicht machbar wäre:
<pre>
#define PSTR(s) \
({ \
static char __c[] PROGMEM = (s); \
__c; \
})
</pre>

==Reihenfolge der Auswertung==

=Kontrollanweisungen=

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

b1= b2 && b3;

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

b1= b2 || b3;

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

b1= !b2;

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

==<tt>if</tt>-Anweisung==
Syntax: IF (Bedingung) Anweisung;
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:

[[bild:ifthenelse.png]]

Und in C schreibt man:
<pre>
if (Bedingung) // WENN
{ // DANN
Anweisung1;
}
else
{ // SONST
Anweisung2;
}
</pre>
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.

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

<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki>

<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki>

Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.
}}

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

===<tt>while</tt>-Schleife===
'''Syntax:''' while (Bedingung) { Anweisung; }

Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block!

<pre>
Zahl1=0;
while (Zahl1<3)
{
Zahl1=Zahl1+1;
Zahl2=Zahl2*2;
}
</pre>

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.
===<tt>do</tt>-<tt>while</tt>-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. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird

<pre>
unsigned char bData;
do {
bData = getch(); // Tastatureingabe (s.u.)
}while (bData != 13);
</pre>

Die Schleife wird durchlaufen und wiederholt, solange etwas anderes als 13 (<ENTER>) eingegeben wird.

===<tt>for</tt>-Schleife===
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }

Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Hat sie einen bestimmten Wert erreicht, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block

Die gesammte Schleife wird solange durchgeführt, wie die Bedingung TRUE ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.

Die Theorie ist schwer, die Praxis nicht so sehr...

<pre>
int Zaehler;
for (Zaehler = 1; Zaehler <= 10; Zaehler++)
{
Zahl2 = Zahl2 + Zaehler;
}
</pre>
Das Äquivalent als "WHILE"
<pre>
int Zaehler;
Zaehler = 1; // Anfangswerte
while (Zaehler <= 10) // Bedingung
{
Zahl2 = Zahl2 + Zaehler;
Zaehler++; // Inkrement
}
</pre>

In diesem Beispiel wird Zahl2 in jedem Schleifendurchlauf um die Zählvariable Zaehler erhöht. Da Zaehler nacheinander die Werte von 1 bis 10 hat, ist in Zahl2 nach der Schleife die Summe der Zahlen 1 bis 10 gespeichert.

'''Erklärung:'''
Zaehler=1 bedeutet, dass der Variablen Zaehler vor dem 1. Schleifendurchlauf der Wert 1 zugewiesen wird.
Zaehler<=10 ist die Schleifenbedingung; ist sie FALSE, wird die Schleife beendet.
Zaehler++ bedeutet, dass Zaehler nach jedem Durchlauf um 1 erhöht wird.

=Ein- und Ausgabe=

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

Der dazu notwendige Befehl ist printf (das f ist KEIN Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf dem Bildschirm aus (außer, Sie haben unter DOS die Standard-Ausgabe auf ein anderes Gerät, z.B. den Drucker umgeleitet, aber das ist eine andere Geschichte). Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. int, char, float, double) sein!
<pre>
#include <conio.h>
#include <stdio.h>

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

Hinweis:
Dass das Programm nach dem Compilieren und Ausführen sofort wieder beendet wird, ist nicht Ihr Fehler. Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!
Erklärung:

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

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

In der 3. Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet %c "char" (Zeichen). Es wird also %c durch 'A' ersetzt.

Die letzte Ausgabe verhält sich merkwürdig es wird doch tatsächlich eine Zahl ausgegeben, obwohl der Parameter ein Zeichen (char) ist. Aber:
%d im Text bedeutet, dass eine Zahl auszugeben ist.
ein char kann ja auch als Zahl interpretiert werden.
Es wird also 65 (der ASCII-Wert von 'A') ausgegeben. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer char Variablen!

'''Bildschirm löschen'''

Oft sind von anderen Programmen noch "Rückstände" vorhanden. Nicht nur um die zu beseitigen, brauchen Sie einen "Bildschirm-Lösch-Befehl". Dieser ist in conio.h definiert und nennt sich "clrscr" ("clear screen", deut: "lösche Bildschirm").
<pre>
#include <conio.h>
#include <stdio.h>

void main(void)
{
clrscr();
...
}
</pre>

==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.
Der wichtigste Befehl ist "scanf". Er liest Daten von der Tastatur. Die Syntax entspricht derer von printf, nur daß man außer den %c und %d keine weiteren Angaben im "Text" machen darf:

<pre>
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. Diese Zahl wird in Zahl1 abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

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

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

===getch===
getch ist eine Funktion (Siehe Kapitel Unterprogramme), die ein char-Zeichen von der Tastatur einliest. Dazu geben Sie im Programm einfach folgende Zeile an:

<pre>
char zeichen;
zeichen = getch();
</pre>
Diese Zeile erwartet die Eingabe eines char-Zeichens. Im Gegensatz zu scanf muß man nach der Eingabe des Zeichens jedoch nicht [ENTER] drücken, um die Eingabe zu bestätigen. In der Variable zeichen wird das erste Zeichen gespeichert, das auf der Tastatur eingegeben wird.

Eine weiter Möglichkeit der Anwendung von getch ist es, wenn Sie einfach "getch();" als Befehl eingeben. Dann wartet der Computer, bis Sie eine Taste drücken, speichert diese aber nicht ab.

===kbhit===
Dies ist ebenfalls eine Funktion, die eine boolschen Ausdruck zurück liefert. Sie gibt Bescheid darüber, ob eine Taste gedrückt wurde, und mit scanf oder getch abgerufen werden kann (zum Verständnis: auf der Tastatur eingegebene Zeichen werden meist nicht direkt vom Programm verarbeitet, sondern erst vom Betriebssystem bzw. dem BIOS des Computers gespeichert. Wenn das Programm nun eine Eingabe erwartet, werden die gespeicherten Zeichen "verwendet". Dies lauft jedoch so schnell ab, daß der Benutzer davon nichts merkt). Ist diese Variable TRUE, dann ist ein Zeichen abfragebereit, sonst nicht:

<pre>
while ( !kbhit() )
{
Zahl1=Zahl1+1;
printf("%d\n",Zahl1);
}
</pre>

Dieser Programmteil erhöht solange Zahl1 und gibt diese aus, bis der Benutzer eine Taste drückt.

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

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

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

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

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

void main(void)
{
int zahl1,ergebnis;

printf("Bitte Zahl eingeben: ");
scanf("%d",&zahl1);
ergebnis = hoch2(zahl1);
printf("%d hoch 2 = %d\n",zahl1,ergebnis);
printf("5 hoch 2 = %d\n",hoch2(5));
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen.
Geschachtelte-Unterprogramme wie z.B. in Pascal sind nicht möglich.
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Bei z.B. getch() ist das char. Danach folgt der Name der Funktion (case-sensitiv!). Danach kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden, und mittels Beistrich voneinander getrennt werden. Am Ende ist kein Beistrich!
Im Block der Funktion können alle Anweisungen ausgeführt werden und Variablen deklariert werden.
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung "return" und dem Rückgabewert.
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an "Variable=Funktion(Parameter);". Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

==Prozedur==
'''Syntax:''' void Name(Parameterliste);

Eine Prozedur ist nichts anderes als eine Funktion ohne Rückgabewert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede:

Als Rückgabe-Datentyp wird void angegeben.
Eine Prozedur kann daher beim Aufruf nicht einer Variablen zugewiesen werden (wie FUNCTION's) sonder wird wie eine normale Anweisung behandelt (wie z.B. printf).

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

void ausgeben(int Param1);
{
printf("Der Wert der Variablen beträgt: %d\n",Param1);
}

void main(void)
{
int Zahl1;
ausgeben(23);
Zahl1=4;
ausgeben(Zahl1);
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Durch den Befehl "ausgeben(23)" wird die Prozedur "ausgeben" mit dem Parameter 23 aufgerufen. Param1 hat also den Wert 23. Die einzige Anweisung innerhalb der Prozedur ist printf, was nun ausgeführt wird.
Danach wird mit dem nächsten Befehl innerhalb des Hauptprogrammes fortgefahren ("Zahl1=4").
Der 2. Aufruf von ausgeben erfolgt mit dem Parameter Zahl1, also wird Param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels printf ausgeben.
Unterprogramme ohne Parameter
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, z.B. main, haben statt der Parameter immer nur void stehen. Was bedeutet das? Nun ja, C erwartet, das Sie die Parameter angeben. void bedeutet "es gibt keine Parameter". "void main(void)" bedeutet also: "Erstelle ein Unterprogramm Namens main, das keinen Rückgabewert und keine Parameter hat".

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, z.B. getch, müssen Sie beim Aufruf trotzdem die Klammern angeben. Der Befehl "getch;" führt nicht getch ohne Parameter aus, sondern liefert die Adresse der Funktion getch. Alles klar? Na ja, jedenfalls: Beim Aufruf jedes Unterpgrogrammes immmer Klammern angeben.
}}

==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 1. Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Definition davor erledigt haben. Verstanden?
Um dies zu erreichen, gibt es zwei Möglichkeiten:

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

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

void ausgeben(int Zahl); //Der Prototyp

void main(void)
{
clrscr();
ausgeben(12);
getch();
}

void ausgeben(int Zahl) //Die eigentliche Prozedur
{
printf("Ausgabe: %d\n",Zahl);
}
</pre>

=Besondere Datentypen=

==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 <conio.h>
#include <stdio.h>
#include <string.h>

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

strcpy(stri1,"hallo");
clrscr();
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);
getch();
}
</pre>

'''Hinweis:'''
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, brauchen Sie kein & bei scanf angeben!

'''Erklärung:'''
Es werden 2 gleich große Strings definiert: stri1 und eingabe, mit je 20 "nutzbaren" Zeichen.
stri1 wird der Wert "hallo" zugewiesen. Das 0-Zeichen wird automatisch angefügt!
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt %s ins Spiel. Es hat die gleiche Aufgabe wie %d oder %c, nur halt für Strings.
Sie werden gebeten, eine String einzugeben.
Dieser String wird danach in die Variable stri1 kopiert.
Beide Strings (die ja nun auch den selben Wert haben) werden ausgegeben.

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

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

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

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

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

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

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

void main(void)
{
int Zahl;
printf("Zahl eingeben: ");
scanf("%d",&Zahl);
erhoehe(&Zahl);
printf("\nDie erhoehte Zahl lautet: %d\n",Zahl);
getch();
}
</pre>

==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: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
void 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>

void 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!

'''Autoren'''
* Plasma
* Bernd

'''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://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]]

Diskussion:C-Tutorial

2006-04-28T05:12:50Z

Johannuhrmann: /* volatile */

'''Habt ihr ihr auch texte aus Buchern oder Tutorials hier reingesetzt?'''

Ich würde die Kapitelnummern weglassen. Wenn Du es mit den Gleichheitszeichen strukturierst reicht das völlig und ist übersichtlicher!

--[[Benutzer:Frank|Frank]] 22:49, 16. Dez 2005 (CET)

== einige Anmerkungen ==

* main ist ''nicht'' vom Typ void, sondern liefert int. Einige Compiler unterstützen main auch als void, dazu müssen aber spezielle Schalter angegeben werden.
* C unterscheidet zwischen Groß- und Kleinschreibung bei allen Bezeichnern.
* Quellen werden besser lesbar, wenn man Leerzeichen benutzt, z.b. nach ',' in Argumentlisten oder Deklarationen
* Quellen werden besser lesbar, wenn man Code-Konventionen verwendet, z.b. Makro-Namen groß zu schreiben: DAS_IST_EIN_MAKRO, Funktionsnamen klein: <tt>eine_funktion()</tt> oder <tt>eineFunktion()</tt> und selber definierte Typen klein mit nachgestelltem _t: <tt>mytype_t</tt>
* '''an vielen Stellen ist falscher Code''', der kein C ist! Bevor man so was in ein Tutorial stellt, sollte man sich im klaren sein, was C ist und was nicht. Etwa das Beispiel zu PERSON ist komplett inkorrekt und verwirrt mehr als er erhellt!
* An vielen Stellen werden Begriffe nicht korrekt benutzt, etwa "Deklaration" anstatt "Definition" oder umgekehrt. Dudem sollte geklärt sein, was der Unterschied überhaup ''ist''.
* In C gibt es '''kein Typ boolean''', bool o.ä. C ist kein Pascal. Ebenfalls nicht definiert sind TRUE und FALSE. Boolsche Variablen in C werden durch int abgebildet -- zumindest in Standard C.

Das Tutorial ist noch nicht perfekt. Jeder kann natürlich Korrekturen und Verbesserungen einbringen, einfach ändern.
--[[Benutzer:Bernd|Bernd]] 12:02, 20. Dez 2005 (CET)

Jeder hat meinen ganzen Respekt, wenn er sich die Arbeit macht und solche ausführlichen Artikel schreibt.
Bitte das also als positive Kritik zu sehen.
Aaaaaber: Grad bei einem Tutorial MÜSSEN auch die Details stimmen !! Und jeder Autor trägt da auch Verantwortung !
Bitte, die Autoren mögen den Artikel nochmal gaaaanz genau durcharbeiten. Es sind sehr viele Einzelheiten, die den Laien auf's Glatteis führen und den Wissenden die Nase rümpfen lassen.
*eine variable ist eine variable, das hat mit RAM prinzipiell nix zu tun
*Wieviele Daten passen in eine Variable ? (immer genau ein Datum)
*die Bitanzahl von int ist etwas differenzierter als dargestellt, ganz zu schweigen von "unsigned" Varianten
*In der Mitte von "for" steht keine Abbruchbedingung, sondern eine Laufbedingung
*"case sensitiv" heißt nicht, man muß kleinschreiben, sondern man muß drauf aufpassen
Bitte keine Codebeispiele, wo der Compiler sofort auszuckt. Das muß man ausprobieren oder nochmal lesen, bevor man einen Einsteiger frustrierten in die Wüste schickt.
--PicNick 12:57, 20. Dez 2005 (CET)

----

Ihr könnt gerne alles verbessern, aber bitte keine Fehler einbauen. Ihr habt das Beispiel
<pre>
intVariable = 123; //entspricht in Pascal: boolVariable:=true;
intVariable = 1; //entspricht in Pascal: boolVariable:=true;
intVariable = 0; //entspricht in Pascal: boolVariable:=false;
</pre>
vermutlich falsch verstanden. ''intVariable'' ist ein Variablenname, daher darf es nicht ''int Variable'' lauten.

----
"aber bitte keine Fehler einbauen." Was ist mit "const" ? bleibt das so ? Es ist blöd, wenn da dutzende Leute immer gleichzeitig den selben Artikel beflastern müssen. --PicNick 12:24, 21. Dez 2005 (CET)

----

Ich bin erst mal fertig. Ihr könnt den Text also ergänzen / ändern wenn ihr wollt. Allerdings folgende Ergänzung von euch, "long long" bei den Typen, ist verwirrend. Man spricht von Double, "long long" ist kein echter Begriff aus der C Fachliteratur.
: double ist eine Gleitpunktvariable während long long eine 8byte Ganzzahl ist. long long ist C99-Standard. veraltete Fachliteratur? :-) --[[Benutzer:Fluchtpunkt|Fluchtpunkt]] 03:08, 25. Dez 2005 (CET)

----
evtl sollte man sämtliche Compiler-, Betriebssystem- bzw. Programmspezifischen Sachen entfernen bzw umschreiben; zB gibt es unter linux (mit gcc als Standardcompiler) keine conio.h; Und Erklärungen wie "Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!" sind für Menschen die nicht die selbe IDE wie der Schreiber nutzen eher verwirrend als nützlich. Allerdings müsste man sich darüber klar werden wie das ganze aussehen soll, ich würde nämlich einfach alles, was nicht überall funktioniert, ganz einfach rauskicken; vielleicht tuts aber auch ein Hinweis das dies und jenes nur da und dort funktioniert.

IDE-Optionen würde ich allerdings durch allgemeinere Anweisungen ersetzen, da bringt es relativ wenig einen Weg für alle 1000 Programme zu beschreiben. Bevor ich da aber irgendwas rumpfusche würde ich dazu lieber erstmal andere Meinungen hören.

man sollte sich imho auch auf reines ANSI-C (99?) beschränken um Neulinge nicht schon bei ihren ersten Gehversuchen mit pfuschigem Code zu "versauen". void main(void) ist da ein gutes Beispiel.
Das erspart später auch Fragen wenn User mal an einen Compiler geraten der 100% korrektes ANSI-C will.

War oder ist eigentlich geplant das aus diesem Tutorial mal eins wird das mehr auf Mikrocontrolleranwendungen konzentriert ist? --[[Benutzer:Fluchtpunkt|Fluchtpunkt]] 03:08, 25. Dez 2005 (CET)
----
Es ist sicher nicht so einfach, ein C-Tutorial zu schreiben, ohne seine Zeilgruppe zu kennen. Kommt der Leser vom Nirwana oder ist er ein ausgepuffter XXX-Programmierer, der jetzt auch C schreiben will ?
Sicher ist irgendeine PC-Workbench als Demonstrationsobjekt für so eine Einschulung weniger geeignet, und eine Spezialisierung auf Controller täte, glaub ich, allen dahingehenden Artikeln gut.

btw: Die Entfernung von "then" ist einserseit ok, gibt's in C ja nicht. Aber die offizielle Bezeichnung der Bedingung ist eben "if-then-else". Geht man eben auf Theorie oder Praxis ? Nächstes Problem wäre dann "select case", der beim C ja mit "switch" beginnt.

--PicNick 10:49, 25. Dez 2005 (CET)
: zumindest hat dieses Textfeld mit dem if then else den Anschein das es sich um C-Code handelt. Und das produziert einen Compilerfehler. Pseudocode oder Vergleiche mit anderen Sprachen sollten zumindest so gekennzeichnet sein; zB als C-Kommentar. Denn idR tippt der blutige Anfänger einfach alles ab und drückt auf kompilieren. Und postet dann im Forum und beschwert sich das hier falsches Zeug steht. --[[Benutzer:Fluchtpunkt|Fluchtpunkt]] 03:57, 26. Dez 2005 (CET)
----
Es wäre vielleicht sinnvoll dieses Tutorial als grundlegendes nicht compilerspezifisches Tutorial in C zu verstehen. Damit man sich so ein kleinen Einblick vom Standard C machen kann. Eine praktische Einführung könnte man als Ergänzung zu dem GCC-Artikel vielleicht unter [[WinAVR]] ausbauen.

--[[Benutzer:Frank|Frank]] 14:03, 25. Dez 2005 (CET)
----
habe gerade mal ein paar Flussdiagramme erstellt und versuche die nach und nach in das Tutorial einzuarbeiten.

und mal noch ein paar Punkte zur Diskussion
* im Allgemeinen würde ich im Tutorial auf Konstrukte wie "if (foo) bar;" verzichten; sondern alles schön lehrbuchmässig mit { } machen. Das erspart imho einige Verwirrungen. Das es auch anders geht kann man am Ende in einer Art "Tipps und Tricks"-Sektion erklären.
* die Flussdiagramme und der Pseudo-C-Code ala Anweisung1; reichen imho aus. reale Beispiele wie i=2; statt Anweisung1 sollte sich der Leser selbst denken können. Soll heissen 3 mal dasselbe sagen erscheint mir unsinnig. Ich ändere das jetzt erstmal in der If-Anweisung so wie ich mir das vorstelle und hoffe auf Kritik.
*'' "Vergleiche von Variablen" sollte man imho mit zur If-Bedingung packen. Da passt es thematisch besser. Konstrukte wie i = a > 2; sind ja eher selten. so grundlegende Änderungen in der Struktur mach ich allerdings nicht einfach so. => Diskussion willkommen''
* Vergleiche mit anderen Programmiersprachen, wie zB das fehlende then in C, braucht man imho zumindest im Tutorial nicht. Es würde den Rahmen sprengen alle Unterschiede zu gängigen Sprachen herauszustellen. Natürlich wären Tutorials der Art Pascal=>C toll, das hätte mir auch erspart das ich bei jeder neuen Sprache über die Grundsätze der Variablenzuweisung lesen musste; Aber für alle die nicht mit der je nach Autor erwähnten Sprache aufgewachsen sind wäre das Wissen wie etwas in einer anderen Sprache gelöst wird nutzloses Zusatzwissen; und das stiftet imho sehr viel Verwirrung "es gibt also ein then. Aber das wird in C nicht benutzt...". Ich denke ihr versteht worauf ich hinauswill.. würde das also lieber weglassen. Und lieber einen Artikel, ähnlich dem Quellcodevergleich, schreiben in dem man sieht wie man bestimmte Sachen unter der und der Sprache löst; allerdings passt das eher in ein Programmierwiki :) --[[Benutzer:Fluchtpunkt|Fluchtpunkt]] 03:57, 26. Dez 2005 (CET)

----
Wenn irgendwer mal auf die Idee kommt, ein Tutorial eine anderen Sprache zu schreiben (meinethalben Bascom) wird er bei den Schleifen- und Verzweigungskonstrukten wieder von vorn beginnen. Früher war's mal so, da hat man "Programmieren" erst grundsätzlich gelernt, und das Wissen dann mal in dieser, mal in jener Sprache angewandt.
--PicNick 11:48, 26. Dez 2005 (CET)

----
Ich wäre in einem Tutorial auch mehr für die Standard Schreibweise in C. Du musst davon ausgehen das ein C Artikel sowieso selten von jemanden gelesen wird der sich für Bascom entschieden hat. Der Versuch mehrere ganz verschiedene Dinge in einem Artikel zusammenzufassen führt immer zu kommplizierten schwerer verständlich Artikeln. Warum sollte man in bascom die Schleifen etc. nicht wiederholen, Platz haben wir doch, Priorität können wir da auf Verständlichkeit legen.
--[[Benutzer:Frank|Frank]] 12:37, 26. Dez 2005 (CET)

== volatile ==

<tt>volatile</tt> ist keine Speicherklasse, es ist ein Qualifier (ebenso wie z.B. <tt>signed</tt>, <tt>unsigned</tt> oder <tt>const</tt>.

Was die Verwendung von <tt>volatile</tt> angeht wären noch die SFRs hinzuzufügen, und nicht jede Variable die in einer ISR verwendet wird muss volatile sein. Wenn z.B eine Variable ''nur'' in einer ISR verwendet wird (z.B um Ereignisse zu zählen), dann braucht sie nicht <tt>volatile</tt> sein. Trotzdem ist der Code ok.
--[[Benutzer:SprinterSB|SprinterSB]] 18:24, 24. Apr 2006 (CEST)

----

SFR? Jetzt stehe ich grade auf dem Schlauch...
Das mit ''nur in der ISR'' glaubte ich mit dem Zusatz ''global'' erschlagen zu haben.

Gerade für Anfänger sehe ich in einer globalen nicht-volatile Variablen, die nur in einer ISR
verwendet wird, die Gefahr, dass man dann später doch "mal eben so" von anderen Codeteilen
darauf zugreift.

--[[Benutzer:Johannuhrmann|Johannuhrmann]] 21:33, 25. Apr 2006 (CEST)

Die unkorrekte/fehlende Verwendung von volatile oder nicht atomarem Code ist einer der häufigsten Anfängerfehler, das stimmt. Andererseit ist es ein C-Tutorial (oder soll es mal werden), und da sollte man schon drauf achten, daß man die Dinge korrekt beschreibt. Und mach mal einem Anfänger klar, was der Unterschied ist zwischen
int volatile * ptr;
und
int * volatile ptr;

Zugegeben, das fordert an vielen Stellen einen Spagat zwischen Korrektkeit, Verständlichkeit und Pragmatismus. Anhand der Ausnahme könnte man auch erklären, warum es an der Stelle ok ist, volatile nicht zu nehemen. IMHO bringt das für das Verständnis mehr, als eine "muss immer sein" Klausel.

Weiterer Übelstand an der Stelle ist, daß C keine Vorstellung von ISRs hat (zumindest nicht im Standard, da muss jeder Compilerbauer sein eigenes Süppchen machen und ne API stricken). In einem Abschnitts "Interrupts", wo solche Hinweise vielleicht besser gefunden werden als unter "Speicherklasse" oder "Qualifier" (wer wird so spannende Abschnitte überhaupt anclicken?), hätte man zu Interrupts nicht viel zu sagen.

volatile ist übrigens nur die Hälfte der Miete. Wenn die betroffene Variable ein int ist, recht volatile nicht aus... In [[Fallstricke bei der C-Programmierung]] steht ein bisschen was dazu.

Bei dem Beispiel, wo eine globale Variable nur in einer ISR verwendet wird, könnte man auch eine lokale statische Variable nehmen, stimmt. Jedoch könnte es auch eine globale Variable sein, die nur in ISRs (die sich nicht gegenseitig unterbrechen können) verwendet wird. Einfach zu verstehen (oder zu erklären) sind die Feinheiten freilich nicht gerade. Hier ist dein Ansatz bestimmt besser und einfacher zu verstehen für den Neuling.

--[[Benutzer:SprinterSB|SprinterSB]] 23:35, 25. Apr 2006 (CEST)

Benutzer Diskussion:SprinterSB

2006-04-25T19:47:47Z

Johannuhrmann:

Hi,
wegen Deinem Buchgewinn ([[Verlosung]]) bräuchte ich noch Adresse. Am besten per Mail senden.
http://www.roboternetz.de/roboternetzmail.gif
Gruß Frank

--[[Benutzer:Frank|Frank]] 16:50, 25. Jan 2006 (CET)

----

Sag, Sprinter, ist das Wunschthema "code-vergleich von avr-compilern" von dir eingefügt ? Ich weiß nicht ob es gut ist, wenn man als Autor einen Artikel, den man schreiben will, gleich mal als Wunschthema einträgt. Würd' ich nicht gut finden

--PicNick 10:10, 14. Feb 2006 (CET)

----

Ja, das Thema ist von mir. Warum sollte ich nicht Interesse an einem bestimmten Thema haben dürfen, nur weil ich hier auch als Autor bin? Oder versteh ich schlichtweg nicht, was du sagen willst?

--[[Benutzer:SprinterSB|SprinterSB]] 10:58, 14. Feb 2006 (CET)

----
Na ja, was soll's. Ich betrachte die Wunschliste als Maßstab, zu erkennen, was unser Klientel, also der Nachwuchs, für Informationen braucht. Ich häng' auch hemmungslos Themen rein, die ich mag, aber ich stell' sie nicht in die Wunschliste, denn vielleicht interessiert es ja gar keinen (ausser mich).
Ich schreib schon selbst was in die Wunschliste, aber nur, wenn jemand anders darüber schreiben soll.
(Eben, weil ich es ja nicht weiss). Aber lass gut sein, das wird kompliziert.

Codevergleich: Ich hab den Bascom-code recht gut studiert, GCC in etwa, sonst aber null Ahnung. Aber die, die Bascom schreiben, tun das ja meist, weil sie mit Assembler nix am Hut haben. Können die mit der Info was anfangen ? Sag's mir, ich weiß es nicht.
--PicNick 11:24, 23. Feb 2006 (CET)

Ob jemand etwas damit anfangen kann oder sich für ein Thema interessiert, obliegt doch jedem einzelnen. Es ist nicht an mir, darüber zu befinden. Um einen Compiler einordnen/bewerten zu können, ist neben der Benutzerfreundlichkeit, dem Funktionumsumfang, dem Preis, der Erweiterbarkeit, der Dokumentation, dem Service, etc doch auch der erzeugte Code ein entscheidendes Kriterium. Immerhin setzt man einen Compiler ein, ''um Code erzeugen'' zu lassen! Das ist seine Haupt-Aufgabe. Einen Code-Vergleich zu lesen ist m.E. etwas anderes, als in die Assembler-Programmierung einzusteigen. Bei einem Auto interessiert dich ja auch nicht nur die Farbe, wie bequem die Sitze sind, oder ob es elektrische Fenster gibt, sondern auch, was das Teil schluckt oder wie gut die Bremsen sind, oder wie der Durchzug ist. Einen Töff-Fahrer interessieren sogar Leistungs- und Drehmomentkurven, Schräglagenfreiheit oder Nachlauf... Ein "Anwender" kann also durchaus mit Interesse einen Testbericht lesen, ohne selber Tester oder Konstrukteur zu sein.

Was die Wunschliste angeht, wurde da jeder Punkt von einem Autor zugefügt. Aussagekräftiger wäre natürlich eine Strichliste, ''wieviel'' sich an einem Thema interessiert zeigen.

Ich hatte z.B. auch das Wunschthema JTAG angelegt, abwohl ich es weder verwende noch plane einzusetzen. Dennoch finde ich es interessant, und es gibt inzwischen sogar einen Artikel darüber :-)
----
ok, alles klar.

Schräglagenfreiheit ? Was hast du für ein Auto ? Ich kenn das nur vom biken, da mißt man das mit der Kniescheibe oder bei der Chopper mit der Fußraste :-)
--PicNick 15:29, 23. Feb 2006 (CET)
----
Hi,

ich wollte mich nur kurz für Deine Korrektur bei [[Interrupt]] bedanken - da hatte ich ja voll den Wurm drin

--[[Benutzer:Johannuhrmann|Johannuhrmann]] 21:47, 25. Apr 2006 (CEST)

Benutzer Diskussion:SprinterSB

2006-04-25T19:47:20Z

Johannuhrmann:

Hi,
wegen Deinem Buchgewinn ([[Verlosung]]) bräuchte ich noch Adresse. Am besten per Mail senden.
http://www.roboternetz.de/roboternetzmail.gif
Gruß Frank

--[[Benutzer:Frank|Frank]] 16:50, 25. Jan 2006 (CET)

----

Sag, Sprinter, ist das Wunschthema "code-vergleich von avr-compilern" von dir eingefügt ? Ich weiß nicht ob es gut ist, wenn man als Autor einen Artikel, den man schreiben will, gleich mal als Wunschthema einträgt. Würd' ich nicht gut finden

--PicNick 10:10, 14. Feb 2006 (CET)

----

Ja, das Thema ist von mir. Warum sollte ich nicht Interesse an einem bestimmten Thema haben dürfen, nur weil ich hier auch als Autor bin? Oder versteh ich schlichtweg nicht, was du sagen willst?

--[[Benutzer:SprinterSB|SprinterSB]] 10:58, 14. Feb 2006 (CET)

----
Na ja, was soll's. Ich betrachte die Wunschliste als Maßstab, zu erkennen, was unser Klientel, also der Nachwuchs, für Informationen braucht. Ich häng' auch hemmungslos Themen rein, die ich mag, aber ich stell' sie nicht in die Wunschliste, denn vielleicht interessiert es ja gar keinen (ausser mich).
Ich schreib schon selbst was in die Wunschliste, aber nur, wenn jemand anders darüber schreiben soll.
(Eben, weil ich es ja nicht weiss). Aber lass gut sein, das wird kompliziert.

Codevergleich: Ich hab den Bascom-code recht gut studiert, GCC in etwa, sonst aber null Ahnung. Aber die, die Bascom schreiben, tun das ja meist, weil sie mit Assembler nix am Hut haben. Können die mit der Info was anfangen ? Sag's mir, ich weiß es nicht.
--PicNick 11:24, 23. Feb 2006 (CET)

Ob jemand etwas damit anfangen kann oder sich für ein Thema interessiert, obliegt doch jedem einzelnen. Es ist nicht an mir, darüber zu befinden. Um einen Compiler einordnen/bewerten zu können, ist neben der Benutzerfreundlichkeit, dem Funktionumsumfang, dem Preis, der Erweiterbarkeit, der Dokumentation, dem Service, etc doch auch der erzeugte Code ein entscheidendes Kriterium. Immerhin setzt man einen Compiler ein, ''um Code erzeugen'' zu lassen! Das ist seine Haupt-Aufgabe. Einen Code-Vergleich zu lesen ist m.E. etwas anderes, als in die Assembler-Programmierung einzusteigen. Bei einem Auto interessiert dich ja auch nicht nur die Farbe, wie bequem die Sitze sind, oder ob es elektrische Fenster gibt, sondern auch, was das Teil schluckt oder wie gut die Bremsen sind, oder wie der Durchzug ist. Einen Töff-Fahrer interessieren sogar Leistungs- und Drehmomentkurven, Schräglagenfreiheit oder Nachlauf... Ein "Anwender" kann also durchaus mit Interesse einen Testbericht lesen, ohne selber Tester oder Konstrukteur zu sein.

Was die Wunschliste angeht, wurde da jeder Punkt von einem Autor zugefügt. Aussagekräftiger wäre natürlich eine Strichliste, ''wieviel'' sich an einem Thema interessiert zeigen.

Ich hatte z.B. auch das Wunschthema JTAG angelegt, abwohl ich es weder verwende noch plane einzusetzen. Dennoch finde ich es interessant, und es gibt inzwischen sogar einen Artikel darüber :-)
----
ok, alles klar.

Schräglagenfreiheit ? Was hast du für ein Auto ? Ich kenn das nur vom biken, da mißt man das mit der Kniescheibe oder bei der Chopper mit der Fußraste :-)
--PicNick 15:29, 23. Feb 2006 (CET)

Hi,

ich wollte mich nur kurz für Deine Korrektur bei [[Interrupt]] bedanken - da hatte ich ja voll den Wurm drin

--[[Benutzer:Johannuhrmann|Johannuhrmann]] 21:47, 25. Apr 2006 (CEST)

Diskussion:C-Tutorial

2006-04-25T19:37:21Z

Johannuhrmann: /* volatile */

Diskussion:C-Tutorial

2006-04-25T19:33:36Z

Johannuhrmann: /* volatile */

'''Habt ihr ihr auch texte aus Buchern oder Tutorials hier reingesetzt?'''

Ich würde die Kapitelnummern weglassen. Wenn Du es mit den Gleichheitszeichen strukturierst reicht das völlig und ist übersichtlicher!

--[[Benutzer:Frank|Frank]] 22:49, 16. Dez 2005 (CET)

== einige Anmerkungen ==

* main ist ''nicht'' vom Typ void, sondern liefert int. Einige Compiler unterstützen main auch als void, dazu müssen aber spezielle Schalter angegeben werden.
* C unterscheidet zwischen Groß- und Kleinschreibung bei allen Bezeichnern.
* Quellen werden besser lesbar, wenn man Leerzeichen benutzt, z.b. nach ',' in Argumentlisten oder Deklarationen
* Quellen werden besser lesbar, wenn man Code-Konventionen verwendet, z.b. Makro-Namen groß zu schreiben: DAS_IST_EIN_MAKRO, Funktionsnamen klein: <tt>eine_funktion()</tt> oder <tt>eineFunktion()</tt> und selber definierte Typen klein mit nachgestelltem _t: <tt>mytype_t</tt>
* '''an vielen Stellen ist falscher Code''', der kein C ist! Bevor man so was in ein Tutorial stellt, sollte man sich im klaren sein, was C ist und was nicht. Etwa das Beispiel zu PERSON ist komplett inkorrekt und verwirrt mehr als er erhellt!
* An vielen Stellen werden Begriffe nicht korrekt benutzt, etwa "Deklaration" anstatt "Definition" oder umgekehrt. Dudem sollte geklärt sein, was der Unterschied überhaup ''ist''.
* In C gibt es '''kein Typ boolean''', bool o.ä. C ist kein Pascal. Ebenfalls nicht definiert sind TRUE und FALSE. Boolsche Variablen in C werden durch int abgebildet -- zumindest in Standard C.

Das Tutorial ist noch nicht perfekt. Jeder kann natürlich Korrekturen und Verbesserungen einbringen, einfach ändern.
--[[Benutzer:Bernd|Bernd]] 12:02, 20. Dez 2005 (CET)

Jeder hat meinen ganzen Respekt, wenn er sich die Arbeit macht und solche ausführlichen Artikel schreibt.
Bitte das also als positive Kritik zu sehen.
Aaaaaber: Grad bei einem Tutorial MÜSSEN auch die Details stimmen !! Und jeder Autor trägt da auch Verantwortung !
Bitte, die Autoren mögen den Artikel nochmal gaaaanz genau durcharbeiten. Es sind sehr viele Einzelheiten, die den Laien auf's Glatteis führen und den Wissenden die Nase rümpfen lassen.
*eine variable ist eine variable, das hat mit RAM prinzipiell nix zu tun
*Wieviele Daten passen in eine Variable ? (immer genau ein Datum)
*die Bitanzahl von int ist etwas differenzierter als dargestellt, ganz zu schweigen von "unsigned" Varianten
*In der Mitte von "for" steht keine Abbruchbedingung, sondern eine Laufbedingung
*"case sensitiv" heißt nicht, man muß kleinschreiben, sondern man muß drauf aufpassen
Bitte keine Codebeispiele, wo der Compiler sofort auszuckt. Das muß man ausprobieren oder nochmal lesen, bevor man einen Einsteiger frustrierten in die Wüste schickt.
--PicNick 12:57, 20. Dez 2005 (CET)

----

Ihr könnt gerne alles verbessern, aber bitte keine Fehler einbauen. Ihr habt das Beispiel
<pre>
intVariable = 123; //entspricht in Pascal: boolVariable:=true;
intVariable = 1; //entspricht in Pascal: boolVariable:=true;
intVariable = 0; //entspricht in Pascal: boolVariable:=false;
</pre>
vermutlich falsch verstanden. ''intVariable'' ist ein Variablenname, daher darf es nicht ''int Variable'' lauten.

----
"aber bitte keine Fehler einbauen." Was ist mit "const" ? bleibt das so ? Es ist blöd, wenn da dutzende Leute immer gleichzeitig den selben Artikel beflastern müssen. --PicNick 12:24, 21. Dez 2005 (CET)

----

Ich bin erst mal fertig. Ihr könnt den Text also ergänzen / ändern wenn ihr wollt. Allerdings folgende Ergänzung von euch, "long long" bei den Typen, ist verwirrend. Man spricht von Double, "long long" ist kein echter Begriff aus der C Fachliteratur.
: double ist eine Gleitpunktvariable während long long eine 8byte Ganzzahl ist. long long ist C99-Standard. veraltete Fachliteratur? :-) --[[Benutzer:Fluchtpunkt|Fluchtpunkt]] 03:08, 25. Dez 2005 (CET)

----
evtl sollte man sämtliche Compiler-, Betriebssystem- bzw. Programmspezifischen Sachen entfernen bzw umschreiben; zB gibt es unter linux (mit gcc als Standardcompiler) keine conio.h; Und Erklärungen wie "Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!" sind für Menschen die nicht die selbe IDE wie der Schreiber nutzen eher verwirrend als nützlich. Allerdings müsste man sich darüber klar werden wie das ganze aussehen soll, ich würde nämlich einfach alles, was nicht überall funktioniert, ganz einfach rauskicken; vielleicht tuts aber auch ein Hinweis das dies und jenes nur da und dort funktioniert.

IDE-Optionen würde ich allerdings durch allgemeinere Anweisungen ersetzen, da bringt es relativ wenig einen Weg für alle 1000 Programme zu beschreiben. Bevor ich da aber irgendwas rumpfusche würde ich dazu lieber erstmal andere Meinungen hören.

man sollte sich imho auch auf reines ANSI-C (99?) beschränken um Neulinge nicht schon bei ihren ersten Gehversuchen mit pfuschigem Code zu "versauen". void main(void) ist da ein gutes Beispiel.
Das erspart später auch Fragen wenn User mal an einen Compiler geraten der 100% korrektes ANSI-C will.

War oder ist eigentlich geplant das aus diesem Tutorial mal eins wird das mehr auf Mikrocontrolleranwendungen konzentriert ist? --[[Benutzer:Fluchtpunkt|Fluchtpunkt]] 03:08, 25. Dez 2005 (CET)
----
Es ist sicher nicht so einfach, ein C-Tutorial zu schreiben, ohne seine Zeilgruppe zu kennen. Kommt der Leser vom Nirwana oder ist er ein ausgepuffter XXX-Programmierer, der jetzt auch C schreiben will ?
Sicher ist irgendeine PC-Workbench als Demonstrationsobjekt für so eine Einschulung weniger geeignet, und eine Spezialisierung auf Controller täte, glaub ich, allen dahingehenden Artikeln gut.

btw: Die Entfernung von "then" ist einserseit ok, gibt's in C ja nicht. Aber die offizielle Bezeichnung der Bedingung ist eben "if-then-else". Geht man eben auf Theorie oder Praxis ? Nächstes Problem wäre dann "select case", der beim C ja mit "switch" beginnt.

--PicNick 10:49, 25. Dez 2005 (CET)
: zumindest hat dieses Textfeld mit dem if then else den Anschein das es sich um C-Code handelt. Und das produziert einen Compilerfehler. Pseudocode oder Vergleiche mit anderen Sprachen sollten zumindest so gekennzeichnet sein; zB als C-Kommentar. Denn idR tippt der blutige Anfänger einfach alles ab und drückt auf kompilieren. Und postet dann im Forum und beschwert sich das hier falsches Zeug steht. --[[Benutzer:Fluchtpunkt|Fluchtpunkt]] 03:57, 26. Dez 2005 (CET)
----
Es wäre vielleicht sinnvoll dieses Tutorial als grundlegendes nicht compilerspezifisches Tutorial in C zu verstehen. Damit man sich so ein kleinen Einblick vom Standard C machen kann. Eine praktische Einführung könnte man als Ergänzung zu dem GCC-Artikel vielleicht unter [[WinAVR]] ausbauen.

--[[Benutzer:Frank|Frank]] 14:03, 25. Dez 2005 (CET)
----
habe gerade mal ein paar Flussdiagramme erstellt und versuche die nach und nach in das Tutorial einzuarbeiten.

und mal noch ein paar Punkte zur Diskussion
* im Allgemeinen würde ich im Tutorial auf Konstrukte wie "if (foo) bar;" verzichten; sondern alles schön lehrbuchmässig mit { } machen. Das erspart imho einige Verwirrungen. Das es auch anders geht kann man am Ende in einer Art "Tipps und Tricks"-Sektion erklären.
* die Flussdiagramme und der Pseudo-C-Code ala Anweisung1; reichen imho aus. reale Beispiele wie i=2; statt Anweisung1 sollte sich der Leser selbst denken können. Soll heissen 3 mal dasselbe sagen erscheint mir unsinnig. Ich ändere das jetzt erstmal in der If-Anweisung so wie ich mir das vorstelle und hoffe auf Kritik.
*'' "Vergleiche von Variablen" sollte man imho mit zur If-Bedingung packen. Da passt es thematisch besser. Konstrukte wie i = a > 2; sind ja eher selten. so grundlegende Änderungen in der Struktur mach ich allerdings nicht einfach so. => Diskussion willkommen''
* Vergleiche mit anderen Programmiersprachen, wie zB das fehlende then in C, braucht man imho zumindest im Tutorial nicht. Es würde den Rahmen sprengen alle Unterschiede zu gängigen Sprachen herauszustellen. Natürlich wären Tutorials der Art Pascal=>C toll, das hätte mir auch erspart das ich bei jeder neuen Sprache über die Grundsätze der Variablenzuweisung lesen musste; Aber für alle die nicht mit der je nach Autor erwähnten Sprache aufgewachsen sind wäre das Wissen wie etwas in einer anderen Sprache gelöst wird nutzloses Zusatzwissen; und das stiftet imho sehr viel Verwirrung "es gibt also ein then. Aber das wird in C nicht benutzt...". Ich denke ihr versteht worauf ich hinauswill.. würde das also lieber weglassen. Und lieber einen Artikel, ähnlich dem Quellcodevergleich, schreiben in dem man sieht wie man bestimmte Sachen unter der und der Sprache löst; allerdings passt das eher in ein Programmierwiki :) --[[Benutzer:Fluchtpunkt|Fluchtpunkt]] 03:57, 26. Dez 2005 (CET)

----
Wenn irgendwer mal auf die Idee kommt, ein Tutorial eine anderen Sprache zu schreiben (meinethalben Bascom) wird er bei den Schleifen- und Verzweigungskonstrukten wieder von vorn beginnen. Früher war's mal so, da hat man "Programmieren" erst grundsätzlich gelernt, und das Wissen dann mal in dieser, mal in jener Sprache angewandt.
--PicNick 11:48, 26. Dez 2005 (CET)

----
Ich wäre in einem Tutorial auch mehr für die Standard Schreibweise in C. Du musst davon ausgehen das ein C Artikel sowieso selten von jemanden gelesen wird der sich für Bascom entschieden hat. Der Versuch mehrere ganz verschiedene Dinge in einem Artikel zusammenzufassen führt immer zu kommplizierten schwerer verständlich Artikeln. Warum sollte man in bascom die Schleifen etc. nicht wiederholen, Platz haben wir doch, Priorität können wir da auf Verständlichkeit legen.
--[[Benutzer:Frank|Frank]] 12:37, 26. Dez 2005 (CET)

== volatile ==

<tt>volatile</tt> ist keine Speicherklasse, es ist ein Qualifier (ebenso wie z.B. <tt>signed</tt>, <tt>unsigned</tt> oder <tt>const</tt>.

Was die Verwendung von <tt>volatile</tt> angeht wären noch die SFRs hinzuzufügen, und nicht jede Variable die in einer ISR verwendet wird muss volatile sein. Wenn z.B eine Variable ''nur'' in einer ISR verwendet wird (z.B um Ereignisse zu zählen), dann braucht sie nicht <tt>volatile</tt> sein. Trotzdem ist der Code ok.
--[[Benutzer:SprinterSB|SprinterSB]] 18:24, 24. Apr 2006 (CEST)

SFR? Jetzt stehe ich grade auf dem Schlauch...
Das mit ''nur in der ISR'' glaubte ich mit dem Zusatz ''global'' erschlagen zu haben.

Gerade für Anfänger sehe ich in einer globalen nicht-volatile Variablen, die nur in einer ISR
verwendet wird, die Gefahr, dass man dann später doch "mal eben so" von anderen Codeteilen
darauf zugreift.

--[[Benutzer:Johannuhrmann|Johannuhrmann]] 21:33, 25. Apr 2006 (CEST)

C-Tutorial

2006-04-24T14:59:14Z

Johannuhrmann: /* Speicherklassen */

Ein kurzer Einblick in die Programmiersprache C
=Allgemeines=
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 Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.

C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu 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.
<pre>
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

/* Anweisungen */
return 0;
}
</pre>

Die Beschreibung (die Erklärungen folgen):

;<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ücksichtige, 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 Unterprogramm main=
Unterprogramme lernen Sie zwar erst später kennen, aber dieses eine muß sein. In Gegensatz zu anderen Programmiersprachen gibt es in C kein "Hauptprogramm", sondern nur Unterprogramme. Aber woher soll der Computer wissen, welches Unterprogramm er am Beginn ausführen soll? Ganz einfach, er führt immer das Unterprogramm "main" aus. Dieses ist sozusagen 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 Integer Wert als Ergebnis zurückgeliefert. Beim [[Microcontroller]] ist main das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es dann also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß main oft als oft auch als void (Parameterfrei) definiert wird, wie oben im Beispiel zu erkennen. 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.
<pre>
/* void Definition von main ist nur beim Controller üblich
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main
* kein Fehler/Warnung erzeugt wird.
*/
void main(void)
{
}
</pre>
Was das bedeutet, lernen Sie in einem späteren Kapitel. Wichtig ist nur: ohne main ist kein Programm komplett, es lässt sich dann auch nicht ausführen!

=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":

<pre>
void main(void)
{ //der Block "main" beginnt
int Zahl;

{ //ein "namenloser" Block beginnt
//hier stehen Anweisungen
} //der "namenlose" Block endet
} //der Block "main" endet
</pre>

'''Bemerkung:'''
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, und welcher Art diese Daten sind. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können Sie alle möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können).

;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 ab!

===int, char, short, long (ganze Zahlen)===
In Variable dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, -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 recht 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>

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

=== 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 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: In Zukunft werden ich oft 1 als Synonym für "ungleich 0" verwenden. Bitte beachten Sie jedoch, das eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

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

==Zusammengesetzte Datentypen==
===Felder===
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 Felder, sogenannte ''Arrays'', zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits bekanntes Beispiel für ein Array ist ein String. Ein String ist nichts anderes als ein Array des Datentypes char.

'''Syntax:''' Datentyp Variablenname[Anzahl]

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

int main(void)
{
int Zaehler;
int Zahlen[10]; //Zahlen[0] bis Zahlen[9] !!!

for (Zaehler=0; Zaehler<10; Zaehler++)
{
printf ("Bitte Zahl %d eingeben: ", Zaehler);
scanf ("%d", & Zahlen[Zaehler]);
printf ("\n");
}
printf ("Super!\n");
for (Zaehler=0; Zaehler<10; Zaehler++)
printf ("Zahl %d war: %d\n", Zaehler, Zahlen[Zaehler]);
</pre>

'''Bemerkungen:'''
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.

{{FarbigerRahmen|
'''Merke:'''
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!
}}

===Mehrdimensionale Felder===
Manchmal benötigen 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.

==Strings (Zeichenketten)==
Bei einem String handelt es sich um ein Array, das aus einzelnen Zeichen 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.

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

<pre>
struct Person {
char vname[20], nname[20];
char telnr[15];
int alter;
};
</pre>

'''Erklärung:'''
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden 4 Variablen angelege: 3 Strings und ein <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach
struct Person Variablenname;
an.

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:
<pre>
struct Person hubert;

hubert.alter = 32;
</pre>

==Zeiger==
Jede Variable steht an einer genau definierten stelle im Speicher. Diese Stelle kann man in erfahrung bringen. Wie man das macht und was das überhaupt für Vorteile bringt, erfahren Sie in diesem Abschnitt.
Ein Zeiger ist im Prinzip eine (int-) Variable. In ihr ist jedoch keine Zahl gespeichert, sondern eine "Adresse". Diese gibt eine bestimmte Position im Arbeitsspeicher dar. Hier sehen Sie, wie man einen Zeiger definiert und mit ihm arbeitet:

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

void main(void)
{
int Zahl;
int *Zeiger;

Zeiger=&Zahl;
*Zeiger=12;

printf("%d = %d", Zahl, *Zeiger);
</pre>

'''Erklärung:'''
Um einen Zeiger anzulegen, gibt man folgendes an: Datentyp, dann einen Stern (*), anschließend den Namen (und einen Strichpunkt).
Um einen Zeiger auf eine bestimmte Zahl "zeigen" zu lassen, muß man dem Zeiger die Adresse einer Variablen zuordnen. Das funktioniert mittels dem Adress-Operator & (Zeiger=&Zahl).
Jetzt möchten Sie dem Zeiger einen Wert zuweisen. Aber natürlich nicht dem Zeiger, sondern der Variablen, auf die der Zeiger "zeigt". Na, "Zahl=Wert;", werden Sie sagen. Aber wozu dann Zeiger? Na, ja, jednefalls geht das mittels des "Inhalts-Operators" * (*Zeiger=12).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an printf (und jedes andere Unterprogramm) übergeben.

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

Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.
==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!
<pre>
int Zahl1, Zahl2;
char Zeichen;

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

return 0;
}
</pre>
;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 Zahl1 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 int und char dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable FALSE, ansonsten ist Sie TRUE.
intVariable = !0; // entspricht TRUE
intVariable = 0; // entspricht FALSE

==Vergleich von Variablen==
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln:
<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>
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl.
intVariable = Zahl1 <= Zahl2;
das komplette Beispiel zeigt es deutlicher:
<pre>
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */

printf ("Ergebnis: %d\n", i);
</pre>
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").

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

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

==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>: 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.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert.
Eine Variable ist so ein LValue, der etwas zugewiesen werden kann:
a = 1;
Hingegen ist <tt>a+1</tt> kein LValue, denn eine Zuweisung wie
a+1 = 2;
erzeugt einen Compilerfehler, der etwas lautet könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

==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 Eigenheit der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet.

Beispiel:
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */

<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,
die eine aufwändige Operation durchführt.
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.

Wo ist also der Unterschied? 
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.

==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==
==Komponenten-Auswahl bei Structs und Unions==
==Adress-Operator und Dereferenzierung==
==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.

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

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingte Zuweisung===
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;

==Blöcke==
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks.
Der Block muss un runden Klammern stehen:
int sum;
sum = ({
int i, s = 0;
for (i=1; i<= 100; i++)
s += i;
s;
});

Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc,
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer
Instruktion nicht machbar wäre:
<pre>
#define PSTR(s) \
({ \
static char __c[] PROGMEM = (s); \
__c; \
})
</pre>

==Reihenfolge der Auswertung==

=Kontrollanweisungen=

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

b1= b2 && b3;

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

b1= b2 || b3;

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

b1= !b2;

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

==<tt>if</tt>-Anweisung==
Syntax: IF (Bedingung) Anweisung;
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:

[[bild:ifthenelse.png]]

Und in C schreibt man:
<pre>
if (Bedingung) // WENN
{ // DANN
Anweisung1;
}
else
{ // SONST
Anweisung2;
}
</pre>
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.

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

<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki>

<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki>

Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.
}}

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

===<tt>while</tt>-Schleife===
'''Syntax:''' while (Bedingung) { Anweisung; }

Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block!

<pre>
Zahl1=0;
while (Zahl1<3)
{
Zahl1=Zahl1+1;
Zahl2=Zahl2*2;
}
</pre>

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.
===<tt>do</tt>-<tt>while</tt>-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. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird

<pre>
unsigned char bData;
do {
bData = getch(); // Tastatureingabe (s.u.)
}while (bData != 13);
</pre>

Die Schleife wird durchlaufen und wiederholt, solange etwas anderes als 13 (<ENTER>) eingegeben wird.

===<tt>for</tt>-Schleife===
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }

Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Hat sie einen bestimmten Wert erreicht, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block

Die gesammte Schleife wird solange durchgeführt, wie die Bedingung TRUE ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.

Die Theorie ist schwer, die Praxis nicht so sehr...

<pre>
int Zaehler;
for (Zaehler = 1; Zaehler <= 10; Zaehler++)
{
Zahl2 = Zahl2 + Zaehler;
}
</pre>
Das Äquivalent als "WHILE"
<pre>
int Zaehler;
Zaehler = 1; // Anfangswerte
while (Zaehler <= 10) // Bedingung
{
Zahl2 = Zahl2 + Zaehler;
Zaehler++; // Inkrement
}
</pre>

In diesem Beispiel wird Zahl2 in jedem Schleifendurchlauf um die Zählvariable Zaehler erhöht. Da Zaehler nacheinander die Werte von 1 bis 10 hat, ist in Zahl2 nach der Schleife die Summe der Zahlen 1 bis 10 gespeichert.

'''Erklärung:'''
Zaehler=1 bedeutet, dass der Variablen Zaehler vor dem 1. Schleifendurchlauf der Wert 1 zugewiesen wird.
Zaehler<=10 ist die Schleifenbedingung; ist sie FALSE, wird die Schleife beendet.
Zaehler++ bedeutet, dass Zaehler nach jedem Durchlauf um 1 erhöht wird.

=Ein- und Ausgabe=

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

Der dazu notwendige Befehl ist printf (das f ist KEIN Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf dem Bildschirm aus (außer, Sie haben unter DOS die Standard-Ausgabe auf ein anderes Gerät, z.B. den Drucker umgeleitet, aber das ist eine andere Geschichte). Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. int, char, float, double) sein!
<pre>
#include <conio.h>
#include <stdio.h>

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

Hinweis:
Dass das Programm nach dem Compilieren und Ausführen sofort wieder beendet wird, ist nicht Ihr Fehler. Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!
Erklärung:

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

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

In der 3. Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet %c "char" (Zeichen). Es wird also %c durch 'A' ersetzt.

Die letzte Ausgabe verhält sich merkwürdig es wird doch tatsächlich eine Zahl ausgegeben, obwohl der Parameter ein Zeichen (char) ist. Aber:
%d im Text bedeutet, dass eine Zahl auszugeben ist.
ein char kann ja auch als Zahl interpretiert werden.
Es wird also 65 (der ASCII-Wert von 'A') ausgegeben. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer char Variablen!

'''Bildschirm löschen'''

Oft sind von anderen Programmen noch "Rückstände" vorhanden. Nicht nur um die zu beseitigen, brauchen Sie einen "Bildschirm-Lösch-Befehl". Dieser ist in conio.h definiert und nennt sich "clrscr" ("clear screen", deut: "lösche Bildschirm").
<pre>
#include <conio.h>
#include <stdio.h>

void main(void)
{
clrscr();
...
}
</pre>

==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.
Der wichtigste Befehl ist "scanf". Er liest Daten von der Tastatur. Die Syntax entspricht derer von printf, nur daß man außer den %c und %d keine weiteren Angaben im "Text" machen darf:

<pre>
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. Diese Zahl wird in Zahl1 abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

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

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

===getch===
getch ist eine Funktion (Siehe Kapitel Unterprogramme), die ein char-Zeichen von der Tastatur einliest. Dazu geben Sie im Programm einfach folgende Zeile an:

<pre>
char zeichen;
zeichen = getch();
</pre>
Diese Zeile erwartet die Eingabe eines char-Zeichens. Im Gegensatz zu scanf muß man nach der Eingabe des Zeichens jedoch nicht [ENTER] drücken, um die Eingabe zu bestätigen. In der Variable zeichen wird das erste Zeichen gespeichert, das auf der Tastatur eingegeben wird.

Eine weiter Möglichkeit der Anwendung von getch ist es, wenn Sie einfach "getch();" als Befehl eingeben. Dann wartet der Computer, bis Sie eine Taste drücken, speichert diese aber nicht ab.

===kbhit===
Dies ist ebenfalls eine Funktion, die eine boolschen Ausdruck zurück liefert. Sie gibt Bescheid darüber, ob eine Taste gedrückt wurde, und mit scanf oder getch abgerufen werden kann (zum Verständnis: auf der Tastatur eingegebene Zeichen werden meist nicht direkt vom Programm verarbeitet, sondern erst vom Betriebssystem bzw. dem BIOS des Computers gespeichert. Wenn das Programm nun eine Eingabe erwartet, werden die gespeicherten Zeichen "verwendet". Dies lauft jedoch so schnell ab, daß der Benutzer davon nichts merkt). Ist diese Variable TRUE, dann ist ein Zeichen abfragebereit, sonst nicht:

<pre>
while ( !kbhit() )
{
Zahl1=Zahl1+1;
printf("%d\n",Zahl1);
}
</pre>

Dieser Programmteil erhöht solange Zahl1 und gibt diese aus, bis der Benutzer eine Taste drückt.

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

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

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

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

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

void main(void)
{
int zahl1,ergebnis;

printf("Bitte Zahl eingeben: ");
scanf("%d",&zahl1);
ergebnis = hoch2(zahl1);
printf("%d hoch 2 = %d\n",zahl1,ergebnis);
printf("5 hoch 2 = %d\n",hoch2(5));
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen.
Geschachtelte-Unterprogramme wie z.B. in Pascal sind nicht möglich.
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Bei z.B. getch() ist das char. Danach folgt der Name der Funktion (case-sensitiv!). Danach kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden, und mittels Beistrich voneinander getrennt werden. Am Ende ist kein Beistrich!
Im Block der Funktion können alle Anweisungen ausgeführt werden und Variablen deklariert werden.
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung "return" und dem Rückgabewert.
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an "Variable=Funktion(Parameter);". Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

==Prozedur==
'''Syntax:''' void Name(Parameterliste);

Eine Prozedur ist nichts anderes als eine Funktion ohne Rückgabewert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede:

Als Rückgabe-Datentyp wird void angegeben.
Eine Prozedur kann daher beim Aufruf nicht einer Variablen zugewiesen werden (wie FUNCTION's) sonder wird wie eine normale Anweisung behandelt (wie z.B. printf).

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

void ausgeben(int Param1);
{
printf("Der Wert der Variablen beträgt: %d\n",Param1);
}

void main(void)
{
int Zahl1;
ausgeben(23);
Zahl1=4;
ausgeben(Zahl1);
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Durch den Befehl "ausgeben(23)" wird die Prozedur "ausgeben" mit dem Parameter 23 aufgerufen. Param1 hat also den Wert 23. Die einzige Anweisung innerhalb der Prozedur ist printf, was nun ausgeführt wird.
Danach wird mit dem nächsten Befehl innerhalb des Hauptprogrammes fortgefahren ("Zahl1=4").
Der 2. Aufruf von ausgeben erfolgt mit dem Parameter Zahl1, also wird Param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels printf ausgeben.
Unterprogramme ohne Parameter
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, z.B. main, haben statt der Parameter immer nur void stehen. Was bedeutet das? Nun ja, C erwartet, das Sie die Parameter angeben. void bedeutet "es gibt keine Parameter". "void main(void)" bedeutet also: "Erstelle ein Unterprogramm Namens main, das keinen Rückgabewert und keine Parameter hat".

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, z.B. getch, müssen Sie beim Aufruf trotzdem die Klammern angeben. Der Befehl "getch;" führt nicht getch ohne Parameter aus, sondern liefert die Adresse der Funktion getch. Alles klar? Na ja, jedenfalls: Beim Aufruf jedes Unterpgrogrammes immmer Klammern angeben.
}}

==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 1. Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Definition davor erledigt haben. Verstanden?
Um dies zu erreichen, gibt es zwei Möglichkeiten:

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

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

void ausgeben(int Zahl); //Der Prototyp

void main(void)
{
clrscr();
ausgeben(12);
getch();
}

void ausgeben(int Zahl) //Die eigentliche Prozedur
{
printf("Ausgabe: %d\n",Zahl);
}
</pre>

=Besondere Datentypen=

==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 <conio.h>
#include <stdio.h>
#include <string.h>

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

strcpy(stri1,"hallo");
clrscr();
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);
getch();
}
</pre>

'''Hinweis:'''
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, brauchen Sie kein & bei scanf angeben!

'''Erklärung:'''
Es werden 2 gleich große Strings definiert: stri1 und eingabe, mit je 20 "nutzbaren" Zeichen.
stri1 wird der Wert "hallo" zugewiesen. Das 0-Zeichen wird automatisch angefügt!
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt %s ins Spiel. Es hat die gleiche Aufgabe wie %d oder %c, nur halt für Strings.
Sie werden gebeten, eine String einzugeben.
Dieser String wird danach in die Variable stri1 kopiert.
Beide Strings (die ja nun auch den selben Wert haben) werden ausgegeben.

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

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

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

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

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

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

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

void main(void)
{
int Zahl;
printf("Zahl eingeben: ");
scanf("%d",&Zahl);
erhoehe(&Zahl);
printf("\nDie erhoehte Zahl lautet: %d\n",Zahl);
getch();
}
</pre>

==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: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
void 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>

void 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!

'''Autoren'''
* Plasma
* Bernd

'''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://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]]

Benutzer Diskussion:Johannuhrmann

2006-04-24T14:43:57Z

Johannuhrmann:

Wer will, kann mir hier eine Nachricht hinterlassen...
--[[Benutzer:Johannuhrmann|Johannuhrmann]] 16:43, 24. Apr 2006 (CEST)

C-Tutorial

2006-04-23T18:16:55Z

Johannuhrmann: /* Logische (boolsche) Operatoren */

Ein kurzer Einblick in die Programmiersprache C
=Allgemeines=
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 Sprachedefinition entwickelt. C ist mittlerweile von ANSI und ISO standardisiert.
Heutzutage ist C (und ihr Nachfolger C++) die dominierende Programmiersprache. Sehr viele Anwendungen sind in C geschrieben. Leider ist C jedoch nicht einfach zu lernen, daher eignet es sich nur bedingt für Anfänger. Mit etwas Übung kann man damit jedoch sehr effiziente Programme schreiben.

C ist sehr eng an Assembler angelehnt, aber trotzdem Hardware-unabhängig. Das bedeutet, Sie können maschinennahe Programme sehr leicht (aber nicht ganz ohne Aufwand) auf ein anderes System portieren. Sie benötigen dazu 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.
<pre>
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

/* Anweisungen */
return 0;
}
</pre>

Die Beschreibung (die Erklärungen folgen):

;<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ücksichtige, 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 Unterprogramm main=
Unterprogramme lernen Sie zwar erst später kennen, aber dieses eine muß sein. In Gegensatz zu anderen Programmiersprachen gibt es in C kein "Hauptprogramm", sondern nur Unterprogramme. Aber woher soll der Computer wissen, welches Unterprogramm er am Beginn ausführen soll? Ganz einfach, er führt immer das Unterprogramm "main" aus. Dieses ist sozusagen 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 Integer Wert als Ergebnis zurückgeliefert. Beim [[Microcontroller]] ist main das Startprogramm, das nach dem RESET aufgerufen wird. Hier gibt es dann also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß main oft als oft auch als void (Parameterfrei) definiert wird, wie oben im Beispiel zu erkennen. 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.
<pre>
/* void Definition von main ist nur beim Controller üblich
* spezielle Compilereinstellungen sind nötig, damit bei dieser Definition von main
* kein Fehler/Warnung erzeugt wird.
*/
void main(void)
{
}
</pre>
Was das bedeutet, lernen Sie in einem späteren Kapitel. Wichtig ist nur: ohne main ist kein Programm komplett, es lässt sich dann auch nicht ausführen!

=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":

<pre>
void main(void)
{ //der Block "main" beginnt
int Zahl;

{ //ein "namenloser" Block beginnt
//hier stehen Anweisungen
} //der "namenlose" Block endet
} //der Block "main" endet
</pre>

'''Bemerkung:'''
Der "namenlose" Block ist eigentlich unnötig. In den folgenden Kapiteln lernen Sie jedoch bessere Beispiele kennen!

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, und welcher Art diese Daten sind. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können Sie alle möglichen ASCII-Zeichen speichern (alles, was Sie mit der Tastatur erzeugen können).

;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 ab!

===int, char, short, long (ganze Zahlen)===
In Variable dieses Types können Sie ganze Zahlen abspeichern, also z.B. 1, -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 recht 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>

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

=== 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 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: In Zukunft werden ich oft 1 als Synonym für "ungleich 0" verwenden. Bitte beachten Sie jedoch, das eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

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

==Zusammengesetzte Datentypen==
===Felder===
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 Felder, sogenannte ''Arrays'', zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen Zahl_001 bis Zahl_100 arbeiten! Ein ihnen bereits bekanntes Beispiel für ein Array ist ein String. Ein String ist nichts anderes als ein Array des Datentypes char.

'''Syntax:''' Datentyp Variablenname[Anzahl]

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

int main(void)
{
int Zaehler;
int Zahlen[10]; //Zahlen[0] bis Zahlen[9] !!!

for (Zaehler=0; Zaehler<10; Zaehler++)
{
printf ("Bitte Zahl %d eingeben: ", Zaehler);
scanf ("%d", & Zahlen[Zaehler]);
printf ("\n");
}
printf ("Super!\n");
for (Zaehler=0; Zaehler<10; Zaehler++)
printf ("Zahl %d war: %d\n", Zaehler, Zahlen[Zaehler]);
</pre>

'''Bemerkungen:'''
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.

{{FarbigerRahmen|
'''Merke:'''
Wenn Sie einen ungültigen Index angeben (einen, der in der Deklaration nicht enthalten war) können je nach Compiler und Einstellung undefinierbare Dinge passieren, da dadurch andere Variableninhalte oder Programmcode überschrieben wird. Im schlimmsten Fall könnte sogar der Computer/Controller abstürzen. Also achten Sie darauf, daß Sie keine ungültigen Werte als Index angeben!
}}

===Mehrdimensionale Felder===
Manchmal benötigen 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.

==Strings (Zeichenketten)==
Bei einem String handelt es sich um ein Array, das aus einzelnen Zeichen 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.

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

<pre>
struct Person {
char vname[20], nname[20];
char telnr[15];
int alter;
};
</pre>

'''Erklärung:'''
"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden 4 Variablen angelege: 3 Strings und ein <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable dieses Typs <tt>struct Person</tt> anzulegen, geben Sie einfach
struct Person Variablenname;
an.

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt>), einen Punkt und danach den Bezeichner der Komponente:
<pre>
struct Person hubert;

hubert.alter = 32;
</pre>

==Zeiger==
Jede Variable steht an einer genau definierten stelle im Speicher. Diese Stelle kann man in erfahrung bringen. Wie man das macht und was das überhaupt für Vorteile bringt, erfahren Sie in diesem Abschnitt.
Ein Zeiger ist im Prinzip eine (int-) Variable. In ihr ist jedoch keine Zahl gespeichert, sondern eine "Adresse". Diese gibt eine bestimmte Position im Arbeitsspeicher dar. Hier sehen Sie, wie man einen Zeiger definiert und mit ihm arbeitet:

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

void main(void)
{
int Zahl;
int *Zeiger;

Zeiger=&Zahl;
*Zeiger=12;

printf("%d = %d", Zahl, *Zeiger);
</pre>

'''Erklärung:'''
Um einen Zeiger anzulegen, gibt man folgendes an: Datentyp, dann einen Stern (*), anschließend den Namen (und einen Strichpunkt).
Um einen Zeiger auf eine bestimmte Zahl "zeigen" zu lassen, muß man dem Zeiger die Adresse einer Variablen zuordnen. Das funktioniert mittels dem Adress-Operator & (Zeiger=&Zahl).
Jetzt möchten Sie dem Zeiger einen Wert zuweisen. Aber natürlich nicht dem Zeiger, sondern der Variablen, auf die der Zeiger "zeigt". Na, "Zahl=Wert;", werden Sie sagen. Aber wozu dann Zeiger? Na, ja, jednefalls geht das mittels des "Inhalts-Operators" * (*Zeiger=12).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an printf (und jedes andere Unterprogramm) übergeben.

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

Teilweise erlauben C-Compiler auch die Verwendung des Dollar-Zeichens <tt>'''$'''</tt> in Variablennaben.
==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!
<pre>
int Zahl1, Zahl2;
char Zeichen;

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

return 0;
}
</pre>
;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 Zahl1 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 int und char dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable FALSE, ansonsten ist Sie TRUE.
intVariable = !0; // entspricht TRUE
intVariable = 0; // entspricht FALSE

==Vergleich von Variablen==
Sie können Variablen miteinander vergleichen. Das geschieht mit einem der folgenden Zeichen mit den normalen mathematischen Regeln:
<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>
Als Ergebnis bekommen Sie einen logischen Ausdruck in Form einer int-Zahl.
intVariable = Zahl1 <= Zahl2;
das komplette Beispiel zeigt es deutlicher:
<pre>
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z1 /* Ein Vergleich. Die int-Variable i wird wahr, da z1 kleiner als z2 */

printf ("Ergebnis: %d\n", i);
</pre>
Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn z1 kleiner oder gleich z2 ist. Ist z1 jedoch größer als z2, dann ist <tt>i</tt> gleich 0 ("unwahr").

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

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

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

=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.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert.
Eine Variable ist so ein LValue, der etwas zugewiesen werden kann:
a = 1;
Hingegen ist <tt>a+1</tt> kein LValue, denn eine Zuweisung wie
a+1 = 2;
erzeugt einen Compilerfehler, der etwas lautet könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

==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 Eigenheit der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, wenn das Ergebnis bereits feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet.

Beispiel:
(x > 5) || datei_auf_festplatte_gefunden("hallo.txt") /* gut */
datei_auf_festplatte_gefunden("hallo.txt") || (x > 5) /* nicht so gut */

<tt>datei_auf_festplatte_gefunden</tt> ist fiktiv und steht für eine Funktion,
die eine aufwändige Operation durchführt.
Beide Zeilen ergeben <tt>wahr</tt> wenn die Variable x einen Wert größer 5 hat oder
es eine Datei namens <tt>hallo.txt</tt> auf der Festplatte gibt.

Wo ist also der Unterschied? 
In der ersten Zeile wird geprüft, ob x größer als 5 ist und wenn das der Fall ist,
dann wird ''nicht mehr geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte existiert.
In der zweiten Zeile wird ''immer geprüft'', ob <tt>hallo.txt</tt> auf der Festplatte
existiert und erst, wenn sie nicht gefunden wird, wird die Variable x ausgewertet.

==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==
==Komponenten-Auswahl bei Structs und Unions==
==Adress-Operator und Dereferenzierung==
==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.

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

==Zuweisungen und Operatoren mit Nebeneffekt==
===Bedingte Zuweisung===
lvalue = (bediungung) ? if-ausdruck : else-ausdruck;

==Blöcke==
Selbst Blöcke haben in C einen Wert, der in einer Berechnung verwendet werden kann.
Der Wert eines Blockes ist der Wert der letzten Anweisung des Blocks.
Der Block muss un runden Klammern stehen:
int sum;
sum = ({
int i, s = 0;
for (i=1; i<= 100; i++)
s += i;
s;
});

Ein weiteres Beispiel ist das Makro <tt>PSTR</tt> von avr-gcc,
das einen String ins Flash legt und die Adresse zurückliefert, was nur in einer
Instruktion nicht machbar wäre:
<pre>
#define PSTR(s) \
({ \
static char __c[] PROGMEM = (s); \
__c; \
})
</pre>

==Reihenfolge der Auswertung==

=Kontrollanweisungen=

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

b1= b2 && b3;

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

b1= b2 || b3;

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

b1= !b2;

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

==<tt>if</tt>-Anweisung==
Syntax: IF (Bedingung) Anweisung;
Mit Hilfe der IF Anweisung kann man Codeteile (Blöcke) ausführen lassen, wenn die dazugehörige Bedingung erfüllt (TRUE) ist. Im Flussdiagramm sieht eine If-Anweisung folgendermassen aus:

[[bild:ifthenelse.png]]

Und in C schreibt man:
<pre>
if (Bedingung) // WENN
{ // DANN
Anweisung1;
}
else
{ // SONST
Anweisung2;
}
</pre>
Wenn die Bedingung wahr ist wird Anweisung1 ausgeführt. Anschliessend wird aus der If-Bedingung herausgesprungen. Anweisung2 wird also nicht ausgeführt.

Ist die Bedingung unwahr wird gleich zu Anweisung2 gesprungen, diese ausgeführt, und anschliessend wird die If-Bedingung beendet.

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

<nowiki>Ein häufiger Fehler ist statt if(a == 23) etwas wie if(a = 23) zu schreiben. Hier wird allerdings nicht geprüft ob die Variable a gleich 23 ist, sondern der Variable a wird der Wert 23 zugewiesen, und das ist eine wahre Aussage. Anschliessend wird demzufolge der "DANN"-Teil ausgeführt.</nowiki>

<nowiki>Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken. Somit ist dieser kleine Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise if(23 == a). Wenn man dort anstatt des Vergleichsoperator '==' den Zuweisungsoperator '=' verwendet spuckt der Compiler sehr wohl einen Fehler aus.</nowiki>

Ein weiterer häufiger Fehler ist das schreiben von if(Bedingung)''';''' Richtig müsste es heissen "if(Bedingung)" Das fehlerhafte Semikolon im ersten Fall interpretiert der Compiler bereits als Anweisung. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt. Hier also ebenfalls besser zweimal hinschauen.
}}

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

===<tt>while</tt>-Schleife===
'''Syntax:''' while (Bedingung) { Anweisung; }

Die WHILE-Schleife wird solange durchlaufen, wie die Bedingung erfüllt (TRUE) ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Bei mehreren Anweisungen benötigen man einen Block!

<pre>
Zahl1=0;
while (Zahl1<3)
{
Zahl1=Zahl1+1;
Zahl2=Zahl2*2;
}
</pre>

In diesem Beispiel wird die Schleife 3 mal durchlaufen. Zu Beginn des 4. Durchlaufes ist die Bedingung FALSE (Zahl1 ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.
===<tt>do</tt>-<tt>while</tt>-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. Das ist dann sinnvoll, wenn der Vergleichswert für die Bedingung erst im Anweisungsblock gesetzt wird

<pre>
unsigned char bData;
do {
bData = getch(); // Tastatureingabe (s.u.)
}while (bData != 13);
</pre>

Die Schleife wird durchlaufen und wiederholt, solange etwas anderes als 13 (<ENTER>) eingegeben wird.

===<tt>for</tt>-Schleife===
'''Syntax:''' for (Zuweisung;Bedingung;Inkrement) { Anweisung; }

Die FOR-Schleife ist eine spezielle WHILE-Variante für die Formulierung von Zählschleifen. Die angegebene Variable wird am Anfang auf einen Wert gesetzt. Danach wird sie nach jedem Durchlauf verändert (meist um 1 erhöht). Hat sie einen bestimmten Wert erreicht, wird die Schleife beendet. Innerhalb des Anweisungsblockes können Sie auf die Variable zugreifen, d.h. Sie können sie auch verändern. Das ist jedoch nicht ratsam. Wollen Sie mehrere Anweisungen ausführen, benötigen Sie eine Block

Die gesammte Schleife wird solange durchgeführt, wie die Bedingung TRUE ist (d.h. Sie brauchen garnicht die Zählvariable abfragen, Sie können hier auch jede andere Variable auswerten). Inkrement letztendlich wird nach jedem Schleifendurchlauf ausgeführt. Hier kann man z.B. den Zähler erhöhen.

Die Theorie ist schwer, die Praxis nicht so sehr...

<pre>
int Zaehler;
for (Zaehler = 1; Zaehler <= 10; Zaehler++)
{
Zahl2 = Zahl2 + Zaehler;
}
</pre>
Das Äquivalent als "WHILE"
<pre>
int Zaehler;
Zaehler = 1; // Anfangswerte
while (Zaehler <= 10) // Bedingung
{
Zahl2 = Zahl2 + Zaehler;
Zaehler++; // Inkrement
}
</pre>

In diesem Beispiel wird Zahl2 in jedem Schleifendurchlauf um die Zählvariable Zaehler erhöht. Da Zaehler nacheinander die Werte von 1 bis 10 hat, ist in Zahl2 nach der Schleife die Summe der Zahlen 1 bis 10 gespeichert.

'''Erklärung:'''
Zaehler=1 bedeutet, dass der Variablen Zaehler vor dem 1. Schleifendurchlauf der Wert 1 zugewiesen wird.
Zaehler<=10 ist die Schleifenbedingung; ist sie FALSE, wird die Schleife beendet.
Zaehler++ bedeutet, dass Zaehler nach jedem Durchlauf um 1 erhöht wird.

=Ein- und Ausgabe=

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

Der dazu notwendige Befehl ist printf (das f ist KEIN Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf dem Bildschirm aus (außer, Sie haben unter DOS die Standard-Ausgabe auf ein anderes Gerät, z.B. den Drucker umgeleitet, aber das ist eine andere Geschichte). Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. int, char, float, double) sein!
<pre>
#include <conio.h>
#include <stdio.h>

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

Hinweis:
Dass das Programm nach dem Compilieren und Ausführen sofort wieder beendet wird, ist nicht Ihr Fehler. Drücken Sie [ALT] + [F5], um zum Ausgabebildschirm zu kommen!
Erklärung:

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

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

In der 3. Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet %c "char" (Zeichen). Es wird also %c durch 'A' ersetzt.

Die letzte Ausgabe verhält sich merkwürdig es wird doch tatsächlich eine Zahl ausgegeben, obwohl der Parameter ein Zeichen (char) ist. Aber:
%d im Text bedeutet, dass eine Zahl auszugeben ist.
ein char kann ja auch als Zahl interpretiert werden.
Es wird also 65 (der ASCII-Wert von 'A') ausgegeben. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer char Variablen!

'''Bildschirm löschen'''

Oft sind von anderen Programmen noch "Rückstände" vorhanden. Nicht nur um die zu beseitigen, brauchen Sie einen "Bildschirm-Lösch-Befehl". Dieser ist in conio.h definiert und nennt sich "clrscr" ("clear screen", deut: "lösche Bildschirm").
<pre>
#include <conio.h>
#include <stdio.h>

void main(void)
{
clrscr();
...
}
</pre>

==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.
Der wichtigste Befehl ist "scanf". Er liest Daten von der Tastatur. Die Syntax entspricht derer von printf, nur daß man außer den %c und %d keine weiteren Angaben im "Text" machen darf:

<pre>
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. Diese Zahl wird in Zahl1 abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

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

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

===getch===
getch ist eine Funktion (Siehe Kapitel Unterprogramme), die ein char-Zeichen von der Tastatur einliest. Dazu geben Sie im Programm einfach folgende Zeile an:

<pre>
char zeichen;
zeichen = getch();
</pre>
Diese Zeile erwartet die Eingabe eines char-Zeichens. Im Gegensatz zu scanf muß man nach der Eingabe des Zeichens jedoch nicht [ENTER] drücken, um die Eingabe zu bestätigen. In der Variable zeichen wird das erste Zeichen gespeichert, das auf der Tastatur eingegeben wird.

Eine weiter Möglichkeit der Anwendung von getch ist es, wenn Sie einfach "getch();" als Befehl eingeben. Dann wartet der Computer, bis Sie eine Taste drücken, speichert diese aber nicht ab.

===kbhit===
Dies ist ebenfalls eine Funktion, die eine boolschen Ausdruck zurück liefert. Sie gibt Bescheid darüber, ob eine Taste gedrückt wurde, und mit scanf oder getch abgerufen werden kann (zum Verständnis: auf der Tastatur eingegebene Zeichen werden meist nicht direkt vom Programm verarbeitet, sondern erst vom Betriebssystem bzw. dem BIOS des Computers gespeichert. Wenn das Programm nun eine Eingabe erwartet, werden die gespeicherten Zeichen "verwendet". Dies lauft jedoch so schnell ab, daß der Benutzer davon nichts merkt). Ist diese Variable TRUE, dann ist ein Zeichen abfragebereit, sonst nicht:

<pre>
while ( !kbhit() )
{
Zahl1=Zahl1+1;
printf("%d\n",Zahl1);
}
</pre>

Dieser Programmteil erhöht solange Zahl1 und gibt diese aus, bis der Benutzer eine Taste drückt.

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

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

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

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

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

void main(void)
{
int zahl1,ergebnis;

printf("Bitte Zahl eingeben: ");
scanf("%d",&zahl1);
ergebnis = hoch2(zahl1);
printf("%d hoch 2 = %d\n",zahl1,ergebnis);
printf("5 hoch 2 = %d\n",hoch2(5));
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur außerhalb von Blöcken. Siehe auch Prototypen.
Geschachtelte-Unterprogramme wie z.B. in Pascal sind nicht möglich.
In der Deklaration der Funktion kommt zuerst der Rückgabe-Datentyp. Jede Funktion liefert einen Wert zurück, dieser Datentyp gibt den Typ der Variablen an. Bei z.B. getch() ist das char. Danach folgt der Name der Funktion (case-sensitiv!). Danach kommt in Klammern die Parameter-Liste. Dabei handelt es sich um eine Liste von Parametern, die jeweils durch Typ und Name angegeben werden, und mittels Beistrich voneinander getrennt werden. Am Ende ist kein Beistrich!
Im Block der Funktion können alle Anweisungen ausgeführt werden und Variablen deklariert werden.
Am Ende der Funktion muß diese ordnungsgemäß beendet werden. Dies geschieht mittels der Anweisung "return" und dem Rückgabewert.
Um eine Funktion aufzurufen (aus einem anderen Unterprogramm oder main), geben Sie folgendes an "Variable=Funktion(Parameter);". Bei Variable muß es sich jedoch nicht unbedingt um eine von Ihnen deklarierte Variable handeln. Es kann z.B. auch der Parameter für ein weiteres Unterprogramm sein (wie im Beispiel, letzte Zeile).
Die Einrückungen der Anweisungen innerhalb der Funktion nach rechts ist nicht notwendig, sie dient jedoch der Übersicht und ist sehr empfehlenswert.

==Prozedur==
'''Syntax:''' void Name(Parameterliste);

Eine Prozedur ist nichts anderes als eine Funktion ohne Rückgabewert. Sie ist daher prinzipiell gleich aufgebaut wie eine Funktion, bis auf die folgenden Unterschiede:

Als Rückgabe-Datentyp wird void angegeben.
Eine Prozedur kann daher beim Aufruf nicht einer Variablen zugewiesen werden (wie FUNCTION's) sonder wird wie eine normale Anweisung behandelt (wie z.B. printf).

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

void ausgeben(int Param1);
{
printf("Der Wert der Variablen beträgt: %d\n",Param1);
}

void main(void)
{
int Zahl1;
ausgeben(23);
Zahl1=4;
ausgeben(Zahl1);
getch();
}
</pre>

'''Bemerkungen zum Programm:'''
Durch den Befehl "ausgeben(23)" wird die Prozedur "ausgeben" mit dem Parameter 23 aufgerufen. Param1 hat also den Wert 23. Die einzige Anweisung innerhalb der Prozedur ist printf, was nun ausgeführt wird.
Danach wird mit dem nächsten Befehl innerhalb des Hauptprogrammes fortgefahren ("Zahl1=4").
Der 2. Aufruf von ausgeben erfolgt mit dem Parameter Zahl1, also wird Param1 der Wert 4 zugewiesen. Dieser wird nun wieder mittels printf ausgeben.
Unterprogramme ohne Parameter
Das ist ihnen sicherlich schon aufgefallen: Viele Unterprogramme, z.B. main, haben statt der Parameter immer nur void stehen. Was bedeutet das? Nun ja, C erwartet, das Sie die Parameter angeben. void bedeutet "es gibt keine Parameter". "void main(void)" bedeutet also: "Erstelle ein Unterprogramm Namens main, das keinen Rückgabewert und keine Parameter hat".

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, z.B. getch, müssen Sie beim Aufruf trotzdem die Klammern angeben. Der Befehl "getch;" führt nicht getch ohne Parameter aus, sondern liefert die Adresse der Funktion getch. Alles klar? Na ja, jedenfalls: Beim Aufruf jedes Unterpgrogrammes immmer Klammern angeben.
}}

==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 1. Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Definition davor erledigt haben. Verstanden?
Um dies zu erreichen, gibt es zwei Möglichkeiten:

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

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

void ausgeben(int Zahl); //Der Prototyp

void main(void)
{
clrscr();
ausgeben(12);
getch();
}

void ausgeben(int Zahl) //Die eigentliche Prozedur
{
printf("Ausgabe: %d\n",Zahl);
}
</pre>

=Besondere Datentypen=

==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 <conio.h>
#include <stdio.h>
#include <string.h>

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

strcpy(stri1,"hallo");
clrscr();
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);
getch();
}
</pre>

'''Hinweis:'''
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, brauchen Sie kein & bei scanf angeben!

'''Erklärung:'''
Es werden 2 gleich große Strings definiert: stri1 und eingabe, mit je 20 "nutzbaren" Zeichen.
stri1 wird der Wert "hallo" zugewiesen. Das 0-Zeichen wird automatisch angefügt!
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt %s ins Spiel. Es hat die gleiche Aufgabe wie %d oder %c, nur halt für Strings.
Sie werden gebeten, eine String einzugeben.
Dieser String wird danach in die Variable stri1 kopiert.
Beide Strings (die ja nun auch den selben Wert haben) werden ausgegeben.

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

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

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

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

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

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

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

void main(void)
{
int Zahl;
printf("Zahl eingeben: ");
scanf("%d",&Zahl);
erhoehe(&Zahl);
printf("\nDie erhoehte Zahl lautet: %d\n",Zahl);
getch();
}
</pre>

==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: "dir *.exe", "copy *.* a:" oder "ls -la". All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
void 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>

void 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!

'''Autoren'''
* Plasma
* Bernd

'''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://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]]

Benutzer:Johannuhrmann

2006-04-23T10:35:00Z

Johannuhrmann:

'''Johann Uhrmann'''

Informatiker, begeisterter Bastler und Programmierer

Admin des wenig genutzten [[http://www.roboternetz.de/phpBB2/chatroom.php Roboternetz-Chats]]

Interrupt

2006-04-23T10:27:48Z

Johannuhrmann:

===Interrupt Request===

"Ein Interrupt ist ein Signal, meist von einem externen Gerät, mit dem der Prozessor aufgefordert wird, den aktuellen Programmablauf anzuhalten (zu unterbrechen) und eine sog. Unterbrechungsroutine ([[ISR]]) aufzurufen." (Zitat aus der Wikipedia [http://de.wikipedia.org/wiki/Interrupt_Request Interrupt Request])

Man unterscheidet zwischen maskierbaren (d.h. Interrupts, die man unterdrücken kann) und nicht maskierbaren Interrupts.

Sind die Interrupts nicht unterdrückt, wird der normale Programmfluss unterbrochen, sobald ein externes Signal an einer von mehreren Interrupt-Eingängen anliegt. Es wird eine spezielle Unterroutine abgearbeitet ([[ISR]]), die auf das externe Signal reagieren und es ggf. abschalten muss (um erneute Interrupt Requests und damit Endlosschleifen zu vermeiden).

Nicht maskierbare Interrupts werden vor allem für besonders schwerwiegende Ereignisse (z.B. zu hohe Umgebungstemperatur) verwendet, da hier das Steuerprogramm immer unmittelbar reagieren muss, um Schaden vom System abwenden zu können (z.B. indem es eine Kühlung aktiviert).

Da die Anzahl der Interrupt-Leitungen bei Microprozessoren meist begrenzt sind, werden oft Interrupt-Controller vorgeschaltet, die auch kaskadiert (in Serie geschaltet) werden können. Um in solch einem System die Interrupt-Quelle eindeutig identifizieren zu können, muss diese dem Microcontroller über den normalen Datenbus z.B. eine Kennung übermitteln können. Die dazu nötige Kommunikation zwischen Microcontroller und Interrupt-Quelle findet in der Interrupt Service Routine statt.

===Unterschiede zum Polling===

Alternativ zur Verwendung von Interrupts lässt sich das Auftreten eines externes Ereignisses auch durch das regelmäßige Abfragen des externen Gerätes erkennen. Diese Technik nennt sich Polling (der Prozessor ''frägt'' das externe Gerät).

'''Vorteile des Pollings gegenüber der Verwendung von Interrupts:'''
* Es ist einfacher zu implementieren, da die Abfrage des Geräts im Hauptprogramm erfolgen kann.
* Es reagiert meist schneller auf das externe Ereignis. Bei Interrupts wird der aktuelle Befehl des Hauptprogramms noch fertig ausgeführt, dann wird die Rücksprungadresse gesichert und in die [[ISR]] verzweigt. Diese wiederrum muss die zu benutzenden Register auf dem Stack sichern, bevor sie mit der eigentlichen Reaktion auf das externe Ereignis beginnen kann. Beim Polling kann nach Erkennung des Ereignisses sofort reagiert werden.
* Es ist mehr Hardwareaufwand bei den Geräten notwendig, da diese in der Lage sein müssen, auf das Auftreten einer Änderung mit einer Interrupt-Anfrage zu reagieren. (so braucht z.B. ein Temperatursensor für Polling im einfachsten Fall nur einen A/D-Wandler, für die Verwendung von Interrupts muss er auf die Änderung der Temperatur zusätzlich mit einer Interruptanfrage reagieren können)

'''Vorteile von Interrupts gegenüber Polling:'''
* Das Auftreten des externen Ereignisses wird immer überwacht. Beim Polling geschieht dies nur zu den Zeiten, zu denen das Hauptprogramm danach frägt.
* Das Hauptprogramm kann andere Aufgaben übernehmen als das externe Gerät zu überwachen. Beim Polling wird häufig sämtliche Rechenleistung für die Abfrage der Geräte aufgewendet.
* Die Kommunikationsleitungen, Datenbusse und externen Geräte werden entlastet. Im Gegensatz zum Polling wird nur mit dem Gerät kommuniziert, wenn tatsächlich ein externes Ereigniss stattfindet.
* Es ist oft stromsparender. Hat das Hauptprogramm keine Aufgaben mehr zu erledigen, so kann es Teile der CPU bis zum nächsten Auftreten eines Interrupts in einen stromsparenden Sleep-Mode versetzen. In diesem Modus wird die CPU angehalten und beim nächsten Interrupt wieder aktiviert. Fast alle modernen, interruptfähigen Prozessoren unterstützen einen solchen Modus.

<div style="border:2px solid #ffd700; margin-left:auto; margin-right:auto; padding:0.3em; text-align:left; ">
In den allermeisten Fällen überwiegen die Vorteile der Verwendung von Interrupts deutlich!
</div>

===Interrupt-Sharing===
Stehen auf dem Controller weniger Interruptleitungen zur Verfügung, als interruptfähige Geräte angeschlossen werden sollen, so ist es notwendig, dass sich mehrere Geräte eine Interruptleitung teilen (Interrupt-Sharing). Bei einfachen Controllern kann es sogar vorkommen, dass nur eine einzige [[ISR]] definiert werden kann, die bei '''jeder Art''' von Ereignis aufgerufen wird.
In diesem Fall muss die durch den Interrupt aufgerufene [[ISR|Interrupt Service Routine]] prüfen, bei welchem Gerät das Ereignis aufgetreten ist. Das geschieht wiederrum durch Abfrage jedes in Frage kommenden Geräts (also Polling).
==Siehe auch==
* [[ISR]]

[[Kategorie:Microcontroller]]

Transistor

2006-03-06T20:11:35Z

Johannuhrmann: /* Siehe auch */

Ein Transistor ist ein elektronisches Halbleiterbauelement. Man verwendet Transistoren zum Schalten und Verstärken. Die Bezeichnung Transistor ist eine Kurzform vom englischen ''Transfer Varistor'' und soll den Transistor als einen durch Strom steuerbaren Widerstand beschreiben.
Es wird in 2 Hauptgruppen unterschieden:

Bipolare Transitoren und [[FET]]'s (Feldeffekttransistor)

Bipolare Transistoren werden durch Stromfluss angesteuert. Die Anschlüsse des Bipolaren Transistors sind ''Kollektor'' , ''Basis'' und ''Emitter''. Ein kleiner Strom auf der Basis-Emitter-Strecke kann dabei einen großen Strom auf der Kollektor-Emitter-Strecke steuern. Es wird unter anderem auch zwischen NPN und PNP Transitoren unterschieden.

Bei FET's werden die Anschlüsse als Gate (engl. Tor, Gatter), Drain (engl. Abfluss), Source (engl. Quelle) bezeichnet. Der Strom auf der Drain-Source-Strecke wird hier durch die Spannung zwischen Gate und Source gesteuert. Die Steuerung erfolgt (nahezu) stromlos. 

[[Bild:Transistor.gif|center]]
 
== Grundschaltungen ==
===Die NOT Verknüpfung===

[[Bild:NOT Gatter.JPG]]

Diese einfache Schaltung, bestehend aus einem NPN Transistor und zwei Widerständen, invertiert das Eingangssignal, sodass aus beispielsweise +5V (oder logisch 1) 0V (oder logisch 0) erzeugt werden.
Die daraus resultierende Wertetabelle sieht folgendermaßen aus:

<div align = "center">
{| {{Blauetabelle}}
| '''Eingang'''
| '''Ausgang'''
|-
| 0V
| +5V
|-
| +5V
| 0V
|}
</div>
Wenn also an der Transistorbasis +5V angelegt werden (+0,7V reichen meistens auch schon), dann schaltet der Transistor durch und am Ausgang liegen 0V an. Der Strom, der nun durch den Transistor fließt wird durch den Widerstand R2 begrenzt. Wird dieser Widerstand weggelassen, dann wird durch den entstehenden Kurzschluss der Transistor unweigerlich zerstört.
Legt man nun am Eingang 0V an, so sperrt der Transistor und am Ausgang liegen +5V an.

Der Basisstrom wird durch den Widerstand R1 bestimmt. Ein kleiner Widerstand beschleunigt die Schaltgeschwindigkeit des Transistors, ein großer ermöglicht die Ansteuerung auch mit kleinen Strömen.

===Die NAND Verknüpfung===

[[Bild:NAND_Gatter.jpg]]

Die NAND ('''N'''ot'''AND''', d.h. die invertierte Form einer AND Verknüpfung) Verknüpfung besteht aus zwei Transistoren und damit auch zwei Eingängen. Es gibt auch NAND Verknüpfungen, mit mehr Transistoren und folglich auch mehr Eingängen, diese sind im Aufbau aber sehr ähnlich zu der vorgestellten Grund-NAND Verknüpfung.
Schauen wir uns zunächst die Wertetabelle an:
<div align = "center">
{| {{Blauetabelle}}
| '''Eingang 1 (E1)'''
| '''Eingang 2 (E2)'''
| '''Ausgang (A1)'''
|-
| 0V
| 0V
| +5V
|-
| +5V
| 0V
| +5V
|-
| 0V
| +5V
| +5V
|-
| +5V
| +5V
| 0V
|}
</div>

Wie kommt es nun zu dieser Werte- oder auch Wahrheitstabelle?

Wenn an den beiden Eingängen 0V anliegen, dann schaltet keiner der beiden Transistoren durch und der Ausgang ist über den Widerstand R3 mit +5V verbunden.
Wechselt nun einer der beiden Eingänge auf 1, dann schaltet auch nur einer der beiden Transistoren durch und am Ausgang liegen immer noch +5V an. Werden nun aber beide Eingänge mit +5V verbunden, dann schalten beide Transistoren durch und der Ausgang ist leitend mit Masse verbunden.

Die Widerstände (R1, R2, R3) haben die gleiche Funktion wie auch in der NOT Verknüpfung.

== Transistor - Kennwerte ==
Die Transistorkennwerte sind grundsätztlich in Grenzdaten und Kenndaten unterteilt. Grenzwerte dürfen auf keinen Fall überschritten werden, da eine Zerstörung des Transistors unvermeidlich ist. Eigenschaften eines Transistors werden als Kenndaten angegeben, die das Verhalten in bestimmten Arbeitspunkten kennzeichnen.

==Grenzwerte für Sperrschichttemperatur==
Durch die Verlustleistung bei Dauerbetrieb entsteht in der Sperrschicht Wärme, durch die sich die Sperrschichttemperatur erhöht, diese Sperrschichttemperatur '''TJ ''' , darf bestimmte Werte nicht überschreiten, da die Halbleitereigenschaften des Transistors stark verändert würden, was die Zerstörung zur Folge hat. Diese Temperatur hängt vom Halbleitermaterial ab.

'''TJ ''' : 90°C Germaniumtransistoren

'''TJ ''' : 150 - 200°C Siliziumtransistoren

==Grenzwerte für Umgebungstemperatur==
Einige Hersteller geben statt der maximalen Sperrschichttemperatur die höchstzulässige Umgebungstemperatur '''TU ''' als Grenzwert an. '''TU ''' ist stets kleiner als '''TJ '''. Zu diesen beiden Angaben ist in den Datenblättern meistens ein Diagramm zu finden in dem die Temperaturabhängigkeit der höchstzulässigen Gesamtverlustleistung aufgezeigt wird. Aus diesem Diagramm kann die Verlustleistung bei bestimmten Umgebungstemperaturen entnommen werden. Als Parameter ist der Wärmewiederstand '''RTh ''' des Halbleiters aufgetragen. Denn wird durch einen Kühlkörper oder durch die Montage des Transistors an einem Gehäuse die Wärme besser abgeführt, so ist die Gesamtverlustleistung auch bei höheren Umgebungstemperaturen zulässig.

==Zulässiger Arbeitsbereich==
In Transistorschaltungen dürfen bestimmte Grenzwerte nicht überschritten werden. Der zulässige Arbeitsbereich einer Transistorschaltung wird somit durch den Kollektorstrom '''Ic ''', durch die Kollektor - Emitterspannung '''UCE ''' und durch die Verlustleistung '''Ptot ''' begrenzt. Wird der Transistor außerhalb des erlaubten Arbeitsbereiches betrieben wird der Transistor zerstört.

''Autor: ZwieBack - Wiki Konvertierung Frank''

==Siehe auch==
* [[Feldeffekttransistor|FET]]
[[Kategorie:Elektronik]]
[[Kategorie:Grundlagen]]