Allgemeines zu Headerfiles
#include-Anweisungen veranlassen den Praeprozessor, den Text aus der einzubindenden Datei an der Stelle des Befehls einzusetzen. Alle Einbindungen, die mit der Raute "#" beginnen, sind Praeprozessoranweisungen. Der Praeprozessor ist ein etwas fortschrittlicheres Textprogramm mit der Aufgabe, Text zu suchen, zu ersetzen und zu verbinden.
Headerfiles werden meistens in mehreren Dateien benoetigt. Um Doppeldefinitionen und -Deklarationen zu vermeiden, steht am Beginn jedes vernueftigen Headerfiles folgende Define-Anweisung:
// Wenn dieses define noch nich definiert ist #ifndef __STDIO_H // definiere es #define __STDIO_H
Statt der doppelten Unterstriche könnten auch einzelne vorhanden sein. Es hat sich aber eingebürgert, interne Defines mit Doppelunterstrich zu beginnen. So sind sie besser von eigenen Defines zu unterscheiden. Der letzte Buchstabe "H" sagt, dass es sich um einen Headerfile handelt.
In dieser Form richtig aufgebaute Headerfiles können somit über die #include-Anweisung
##include <stdio.h> |
in mehrere Projekt-Quelltexte eingebunden werden, ohne dass auf mögliche Doppeldeklarationen geachtet werden muss. Die richtige Auswahl triff der Praeprozessor.
Erst, nachdem die Arbeit des Praeprozessors getan ist, übernimmt der Compiler dann die Umwandlung in Binaercode. Am Schluss stellt der Linker alle vorgesehenen Verbindungen zwischen den Modulen her. Wenn auch dieser seine Arbeit erfolgreich beenden konnte, ist ein lauffähiges Programm entstanden.
Die Abläufe des gesamten Compilierungsablaufs:
a) Praeprozessor
b) Compilieren
c) Assemblieren
d) Linken
Zeiger und Dereferenzen
Zeiger sind Variablen, in denen Speicheradressen gespeichert werden. Zeiger werden im Code durch einen Stern * dargestellt. Gleichzeitig ist der * aber auch der Dereferenzierungsoperator, mit dem man auf den "Inhalt" eines Zeigers zugreifen kann. Wir wollen uns das an einem kleinen Beispiel ansehen:
// Einen Integer deklarieren und mit 1 intitalisieren int zahl=1; // Nun kann ein Zeiger vom Typ integer deklariert werden int *zeiger; // Diesem zeiger die Speicheradresse von zahl zuweisen zeiger=&zahl;
& bedeutet: Gib mir die Speicheradresse von der folgenden Variablen. zeiger und zahl sind jetzt ein und die selbe Variable. zeiger zeigt nämlich auf den Speicherbereich von zahl. Nur ist zeiger nunmal ein Zeiger (logisch
), und wir können auf die Variable, auf die der Zeiger zeigt, nicht direkt zugreifen (zeiger enthält ja die Speicheradresse, in welcher der Wert im Speicher zu finden ist, nicht der Wert selber). Dafür gibt es jetzt den Dereferenzierungsoperator:
// ein Interger deklarieren und den Wert von zahl dereferenzieren int val=*zeiger;
Nun hat val den Wert von zahl, also 1. Wir haben val den Wert zugewiesen,
auf den der Zeiger zeiger zeigt (hört sich cool an, oder?
).