C-Programmierkurs AD

Transkript

1 C-Programmierkurs Jesko Hüttenhain Lars A. Wallenborn AD Once upon a time, man forged machine, from the heartless stone of the eastern desert. And Yawgmoth, great father of machines, spoke to man: Ye doth be ruler of all machines, but not before ye hath mastered the Lega-C. Inhaltsverzeichnis Lost Scriptures of Korja Less 1 Einführung Der Speicher Maschinencode und Kompilierung Hello World Gcc unter Windows Elementare Sprachkonstrukte Kommentare Variablen Numerische Konstanten Operatoren und Expressions Formalitäten: Statements und Expressions If-Else-Statement Logische- und Vergleichsoperatoren Der Schleifen erster Teil: while Der Schleifen zweiter Teil: for Funktionen Funktionsdefinitionen Funktionsdeklaration vs. Funktionsdefinition Modulares Programmieren und Linken Der Präprozessor Makrodefinition

2 3.4.2 Bedingte Texte Makrodefinition löschen Präprozessor - Compiler - Linker: Ein Beispiel Adressierung und Arrays Adressen und Pointer Statische Arrays Pointerarithmetik Zeichenketten Dynamische Speicherverwaltung Einleitung: Speicherverwaltung Allokierung von Speicher Speichermangel Speicher freigeben Speicherbereiche verändern Funktionen zum Speichermanagement Stringmanipulation Eingabe und Ausgabe Einschub: Kommandozeilenargumente Dateien öffnen In Dateien schreiben Dateien lesen Byteweiser Dateizugriff Den Dateicursor verändern Datenstrukturen Strukturdefinitionen Datenstrukturen Pointer auf Strukturen Intermezzo: Typdefinitionen Anwendung: Verkettete Listen Weitere Sprachkonstrukte Bedingte Auswertung Konstante Variablen Funktionenpointer A Referenzen 71 A.1 Referenz <math.h> A.2 Referenz <time.h> A.3 Referenz <stdlib.h> A.4 Referenz <limits.h>

3 A.5 Referenz <float.h> B Operatorpräzedenzen 76 3

4 1 Einführung 1.1 Der Speicher Wenn wir von Speicher sprechen, so meinen wir nicht die Festplatte, sondern ein Bauteil des Computers, das während des laufenden Betriebs Daten nur für die Dauer eines Programmablaufs abspeichert. Man bezeichnet dies auch als RAM (Random Access Memory). Der Speicher ist eine durchnummerierte Aneinanderreihung von Speicherzellen. Eine Speicherzelle ist ein elektronischer Chip, welcher wiederum 8 Bauteile enthält: Abbildung 1: Der Speicher Diese Bauteile nennt man Bits. Ein Bit kann geladen und entladen werden, hat somit immer genau einen Zustand 1 oder 0. Jede Speicherzelle kann daher 2 8 = 256 Zustände annehmen (mögliche Kombinationen von Zuständen der einzelnen 8 Bits). Fast immer interpretiert man diese Zustände als ganze Zahlen zwischen 0 und 255. Diese Interpretation ist gegeben durch die Darstellung einer Zahl im Binärformat. Eine Speicherzelle bezeichnet man auch als Byte. Die Speicherzelle hat 8 ausgehende Drähte, auf welchen nur Strom fließt, wenn das dazugehörige Bit gesetzt (also 1) ist. Aus technischen Gründen kann immer nur ein ganzes Byte auf einmal gelesen oder neu beschrieben werden, keine einzelnen Bits. Man möchte auch negative Zahlen in Bytes codieren können. Man könnte dafür das erste Bit als sogenanntes Vorzeichenbit reservieren, um sich zu merken, ob die Zahl positiv (Vorzeichenbit gleich 0) oder negativ (Vorzeichenbit gleich 1) ist. Die restlichen Bits können dann nur noch 128 verschiedene Zustände annehmen, also können wir nun die Zahlen von 127 bis 127 darstellen. Dieses Prinzip zeigt anschaulich, dass es einen markanten Unterschied zwischen Daten und deren Interpretation gibt. Ein Byte kann als positive Zahl zwischen 0 und 255 oder aber als vorzeichenbehaftete Zahl zwischen 127 und 127 interpretiert werden. Beides verwendet jedoch das gleiche Speichermedium. Man bezeichnet eine solche Interpretation als Datentyp. In der Realität wird zur Darstellung negativer Zahlen ein anderes Format, genannt Zweierkomplement, verwendet, welches praktischer zu implementieren ist und nur eine Null enthält (das obige Format hat eine +0 und eine 0). Durch Zusammenschluss von Speicherzellen lassen sich auch größere Zahlen darstellen. Den Zusammenschluss von zwei Bytes bezeichnet man als Word (Wort), es kann bereits 2 16 = Zustände annehmen. Ein DWord (Doppelwort) ist 4

5 der Zusammenschluss von zwei Words und daher 4 Bytes oder 32 Bit lang. Es kann zum speichern von Zahlen zwischen 0 und = verwendet werden. Dementsprechend bezeichnet man 64-Bit-Speicherblöcke als QWord (Quad Word). Eine Variable, die nur ein einzelnes Byte umfasst, wird gelegentlich auch als char bezeichnet, für Character. Der Name dieses Datentyps leitet sich daraus her, dass einzelne Buchstaben und andere Zeichen als Zahlen von 0 bis 255 im Computer abgespeichert werden. Zeichenketten und ganze Texte sind somit Speicherblöcke von n aufeinanderfolgenden Bytes (chars), wobei n die Länge der Zeichenkette ist. Gelegentlich ist es nötig, auch über eine Darstellung reeller Zahlen zu verfügen. Dafür werden 8 Bytes Speicher (ein QWord) benötigt, die von einem internen Subprozessor als Kommazahlen interpretiert werden. Auf die genaue Realisierung werden wir nicht näher eingehen. Dieser Datentyp trägt den Bezeichner double. 1.2 Maschinencode und Kompilierung Computer wurden ursprünglich als aufwendige Rechenmaschinen entworfen. Sie alle enthalten einen Kernchip, welcher auch heute noch alle tatsächlichen Berechnungen durchführt. Dieser Baustein ist die Central Processing Unit, auch kurz CPU. Die CPU enthält intern eine sehr geringe Anzahl Speicherzellen (etwa 8 bis 30), die auf modernen Computern für gewöhnlich die Größe eines QWords haben (obwohl auch noch DWords anzutreffen sind). Dies nennt man auch die Registergröße oder Wortgröße der CPU, die Speicherzellen selbst dementsprechend Register. Abbildung 2: Schematischer Aufbau eines Computers 5

6 Die CPU eines Computers kann nur eine sehr geringe Anzahl von rudimentären Rechenoperationen durchführen. Genau wollen wir darauf nicht eingehen, doch besteht ein solcher CPU-Befehl beispielsweise daraus, den Inhalt zweier Register zu addieren, subtrahieren, multiplizieren, dividieren oder ähnliche arithmetische Operationen durchzuführen. Natürlich kann die CPU auch bis zu einer Registergröße Daten aus dem Speicher in ein Register laden, oder aus einem Register Daten in den Speicher schreiben. Jedem CPU-Befehl ist ein numerischer Code zugewiesen, welcher in einem Word gespeichert werden kann. Die so codierten CPU-Befehle heißen Maschinencode. Um ein Computerprogramm auszuführen, liest die CPU aus dem Speicher Maschinencode ein und führt die Befehle nacheinander aus. Es ist nun jedoch ausgesprochen mühsam, auf diese Art und Weise Algorithmen zu implementieren: Dies führte zur Entwicklung von Programmiersprachen, die eine für Menschen wesentlich zugänglichere Syntax vorweisen können. Als Compiler bezeichnet man Programme, die den Programmcode einer Programmiersprache in Maschinencode übersetzen. Diesen Vorgang nennt man Kompilierung. Der Compiler selbst muss freilich irgendwann mühsam als Maschinencode implementiert worden sein. 1.3 Hello World Es ist Tradition, dass junge Schüler einer Programmierdisziplin sich Ihre Hörner an einem sogenannten Hello-World-Programm abstoßen. Ein solches Programm hat keinen Effekt, außer den Text Hello World auf dem Computerbildschirm erscheinen zu lassen. 1 #include <stdio.h> 2 int main() { 3 printf("hello World"); 4 return 0; 5 } Listing 1: Ein Hallo-Welt-Programm in C Wir können an dieser Stelle noch nicht genau auf die Bedeutung aller Programmierbefehle eingehen, wollen aber dennoch alles kommentieren. Die erste Zeile sorgt dafür, dass unserem Programm die Befehle zur Verfügung stehen, um Text auszugeben. Die nächste Zeile markiert den Einstiegspunkt des Programms, d.h. die Stelle, ab der beim Start später mit der Ausführung begonnen werden soll. Die auszuführenden Befehle sind in einem sogenannten Block zusammengefasst, welcher mit geschweiften Klammern umschlossen ist. Die Befehle selbst sind überschaubar: Der erste erzeugt die Ausgabe von Hello World und der zweite beendet das Programm. Dabei wird der sogenannte Fehlercode 0 zurückgegeben, welcher signalisiert, dass beim Ausführen des Programms kein Fehler aufgetreten ist. Dieser Rückgabewert ist für den Anwender des Programms später nicht 6

7 erkennbar: er kann jedoch dazu dienen, verschiedene Programme miteinander kommunizieren zu lassen. Außerdem bemerken wir an dieser Stelle, dass in C jeder Befehl durch ein Semikolon beendet werden muss. Dies ist eine wichtige Regel, deren Missachtung häufig zu scheinbar unerklärlichen Fehlern bei der Kompilierung führt. In der Tat dienen die Zeilenumbrüche im Quellcode nur der Übersichtlichkeit, ein Befehl wird durch das abschließende Semikolon beendet. Daher wäre auch der folgende Quellcode zum obigen äquivalent und absolut korrekt: 1 #include <stdio.h> 2 int main() { printf("hello World"); return 0; } Listing 2: Hallo-Welt in einer Zeile 1.4 Gcc unter Windows Der Compiler, mit dem wir unser Hello World - Programm und auch zukünftige Übungen in ausführbaren Maschinencode übersetzen werden, ist der C-Compiler aus der GnU Compiler Collection, welchen wir hier kurz exemplarisch einführen wollen. Er trägt den Namen gcc. Obgleich er ein sehr weit verbreiteter und gängiger Compiler ist, ist er selbstverständlich nicht der Weisheit letzter Schluss - es gibt eine Vielzahl weiterer Compiler, von denen einige leider nur käuflich zu erwerben sind. Der gcc ist ein unter Linux entwickelter Compiler. Für eine ganze Sammlung von Linux-Programmen existieren Windows-Ports: Diese Sammlung heißt Cygwin. Wir werden hier kurz erläutern, wie Cygwin zu installieren und zu bedienen ist. Von der Seite gilt es, sich die Datei setup.exe herunterzuladen. Im Zweifelsfall wählt man in jedem Schritt die Standartoption und dann Next. Erfahrungsgemäß ist es am günstigsten, alle für den Kurs benötigte Software in einen einheitlichen Ordner (für Windows-User beispielsweise C:\Thor\) zu installieren. Ausserdem sind Leerzeichen im Pfadnamen zu vermeiden. Für den Anfang brauchen wir nur Cygwin, später jedoch noch einige weitere Programme: 7

8 Abbildung 3: Cygwin Installationspfad Im nun folgenden Schritt muss ein weiteres Verzeichnis angegeben werden, in das Cygwin temporär Dateien zwischenspeichern kann. Dieses Verzeichnis ist für den weiteren Gebrauch von Cygwin unerheblich und kann gefahrlos nach der Installation gelöscht werden. Wo dieses Verzeichnis also angelegt wird, ist nicht wirklich wichtig: Abbildung 4: Cygwin Temporäres Verzeichnis Schlussendlich bietet einem das Setup eine ganze Auswahl von ursprünglich für Linux entwickelten Programmen an, deren Windows-Version in dieser Cygwin- Installation enthalten sein soll: 8

9 Abbildung 5: Cygwin Packetauswahl Die Programme, die wir benötigen, sind die folgenden: gcc4-core gdb make automake mintty Dazu sucht man nach dem Namen des entsprechenden Programms und ändert den Status dieses Programms durch clicken von Skip auf die Version, die installiert werden soll: 9

10 Abbildung 6: Cygwin Installation von GCC Cygwin selbst lässt sich nun vom Startmenü aus aufrufen und präsentiert sich als schwarzes Fenster mit einer blinkenden Eingabe, etwa wie folgt: ~ $ Hinter dem Dollarzeichen erwartet Cygwin nun einen Befehl. Es gibt zahlreiche Befehle, einige wichtige haben wir hier für euch aufgelistet: Befehl ls mkdir <name> cd <ordner> cp <quelle> <ziel> mv <quelle> <ziel> rm <datei> Effekt Listet den Inhalt des derzeitigen Verzeichnisses auf. Erstellt einen Ordner mit dem angegebenen Namen Wechselt in den angegebenen Ordner. Kopiert die Datei quelle nach ziel. Verschiebt die Datei quelle nach ziel. Löscht eine Datei. Tabelle 1: Befehle der Cygwin-Kommandozeile Ein einzelner Punkt steht für das derzeitige Verzeichnis und zwei Punkte für das darüberliegende. Der Befehl cd. hat also keinen Effekt und cd.. bewegt sich einen Ordner nach oben. Darüber hinaus ist jedes Programm, dass auf dem Computer (bzw. in Cygwin) installiert ist, ein Befehl. Durch eingabe von notepad beispielsweise öffnet sich der Windows-Texteditor und der Befehl gcc ruft den Compiler auf. Nun wollen wir unser Hello World Programm aus 1.3 kompilieren und ausführen: 10

11 Abbildung 7: Kompilieren von Hello World unter Cygwin Durch notepad helloworld.c erstellen wir die Textdatei helloworld.c. Es ist Konvention, dass Dateien, welche C-Quellcode enthalten, die Dateiendung.c erhalten. Wir bitten freundlich um Einhaltung dieser Konvention unter Androhung ritueller Enthauptung. Nach Tippen des oben angegebenen Quellcodes speichern wir die Datei und kehren zur Kommandozeile zurück. Der Befehl gcc hat folgendes Format: gcc -Wall -pedantic -o EXECUTABLE QUELLDATEI wobei in diesem Fall unsere Quelldatei den Namen helloworld.c trägt. Als Name für die Executable bietet sich der Name helloworld.exe an, doch natürlich steht einem die Entscheidung hier frei. Die Option -Wall ist eine Abkürzung für Warning: All und bedeutet, dass der Compiler alle Warnungen ausgibt. Warnungen sind unser wichtigstes Hilfsmittel, um später Fehler in Programmen zu finden und zu beheben. Nachdem wir den gcc aufgerufen haben, wurde im gleichen Verzeichnis eine Datei erstellt, die helloworld.exe heißt. Der Befehl./helloworld.exe besagt, dass die Datei helloworld.exe im derzeitigen Verzeichnis (der einzelne Punkt) ausgeführt werden soll. 11

12 2 Elementare Sprachkonstrukte 2.1 Kommentare Obgleich Programmiersprachen gedacht sind, um dem Menschen verständlicher zu sein als der kryptische Maschinencode, können nur die wenigsten von uns C-Quellcode wie ein lustiges Taschenbuch lesen. Daher möchte man häufig an verschiedenen Stellen im Quellcode sogenannte Kommentare einfügen, d.h. Erläuterungen und Erklärungen zum Programm, welche nicht vom Compiler als Befehle interpretiert werden sollen. Um einen Kommentar zu beginnen, verwendet man die Zeichenfolge /* und beendet ihn durch die Zeichenfolge */. Ein Beispiel: 1 / HelloWorld v2.1a 2 (c) 2008 by Jesko & Lars / 3 #include <stdio.h> 4 int main() { 5 printf("hello World\n"); 6 return 0; / Programm fehlerfrei beendet / 7 } Listing 3: Hallo-Welt-Programm mit Kommentaren 2.2 Variablen Ganz abstrakt ist ein Programm eine Maschinerie, die gewisse Daten erhält, und daraus neue Daten auf eine bestimmte Art und Weise berechnet. Daten treten in einem Programm stets in Form von sogenannten Variablen auf. Dabei ist eine Variable der Name für eine zusammenhängenden Region im Speicher des Computers, die durch ihren Datentyp eine Interpretation der dort gespeicherten Bits zugewiesen bekommt. Durch den Namen lässt sich im C-Programm die Speicherregion auslesen oder neu beschreiben. Der Programmierer kann sich zu Beginn eines Programmblocks wie folgt Variablen deklarieren (erstellen): DATENTYP NAME = WERT; Wann immer wir Definitionen wie oben angeben, so bedeutet ein unterstrichenes Wort, dass an dieser Stelle verschiedenes stehen kann. Für NAME etwa wird der Name eingefügt, welchen die Variable haben soll. Dies ist eine beliebige Zeichenfolge aus Buchstaben, Ziffern und Unterstrichen, welche nicht mit einer Ziffer beginnt. Der Name der Variablen sollte Aufschluss über ihren Zweck im Programm liefern. Variablennamen mit nur einem Buchstaben, obgleich in der Mathematik sehr verbreitet, sorgen bei Programmen in den meisten Fällen nur für Verwirrung. Ist ein Teil einer Definition grau gefärbt, so ist dieser Teil optional. Wir bemerken, dass das Semikolon oben nicht mehr optional ist. 12

13 Variablentyp Deklaration Ausgabebefehl Ganzzahl int v; printf("%i\n", v); Kleine Ganzzahl signed short int v; printf("%hi\n", v); Große Ganzzahl signed long int v; printf("%li\n", v); Ganzzahl 0 unsigned int v; printf("%u\n", v); Kleine Ganzzahl 0 unsigned short int v; printf("%hu\n", v); Große Ganzzahl 0 unsigned long int v; printf("%lu\n", v); Byte (8 Bit) char c; printf("%c\n", c); Kleine Fließkommazahl float f; printf("%f\n", f); Große Fließkommazahl double d; printf("%f\n", d); Tabelle 2: Die Funktion printf wird später genau erläutert werden Tabelle 2.2 gibt Aufschluss über die zur Verfügung stehenden Datentypen, welche für DATENTYP eingesetzt werden können. Ein int beansprucht stets weniger oder genauso viel Speicher wie ein long int und stets mehr oder genauso viel Speicher wie ein short int. Die gewöhnliche Größe in Bits, die ein int belegt, hat sich im Laufe der Jahrzehnte von 16 über 32 zu mittlerweile 64 Bits gesteigert und könnte sich in der Zukunft weiter ändern. Wir wollen noch etwas genauer verstehen, wie die verschiedenen ganzzahligen Datentypen zusammenhängen. Die Begriffe signed und unsigned sowie short und long sind bei der Deklaration einer int Variablen optional. Wird einer der Ausdrücke nicht angegeben, so wird ein vom Computer und vom Betriebsystem abhängiger Standard gewählt. Sollte allerdings einer dieser Begriffe angegeben werden, so kann int selbst weggelassen werden, etwa so: 1 unsigned x; Optional kann einer Variablen bereits bei der Deklaration ein Wert zugewiesen werden. Diesen Vorgang bezeichnet man als Initialisierung der Variablen. Beispiel: 1 unsigned long pi = 3; / pi wird zu 3 initialisiert / 2 unsigned long x; / x ist undefiniert / 3 unsigned long y = pi; / y wird zu pi initialisiert / Achtung: Wird eine Variable nicht initialisiert, so ist sie undefiniert: Es ist unvorhersehbar, welchen Wert sie hat. Will man mehrere Variablen vom gleichen Typ deklarieren, so ist dies auch möglich, indem man sie nach Angabe des Datentyps lediglich durch Kommata trennt. Damit ist 1 unsigned long pi = 3, x, y = pi; eine Kurzschreibweise für den Quellcode oben. 13

14 2.3 Numerische Konstanten Ganzzahlige Konstanten sind uns bereits bei der Initialisierung von Variablen oben begegnet. Sie werden einfach als Folge von Ziffern in den Code eingegeben. Dabei können Zahlen zu unterschiedlichen Basen angegeben werden, nach folgender Regel: 1. Beginnt die Ziffernfolge nicht mit der Ziffer 0, so wird sie als gewöhnliche Zahlendarstellung im Dezimalsystem verstanden. 2. Andernfalls, wenn die Ziffernfolge mit 0x beginnt, so dürfen außer normalen Ziffern auch die Buchstaben A bis F in der Zahldarstellung verwendet werden. Diese wird dann als Hexadezimalzahl (Darstellung zur Basis 16) interpretiert. 3. Andernfalls, wenn die Ziffernfolge mit 0 beginnt, wird sie als Oktalzahl (Darstellung zur Basis 8) verstanden. In diesem Fall sind die Ziffern 8 und 9 nicht erlaubt. Dies ist insbesondere wichtig zu wissen, um Fehler zu vermeiden: 1 int x1 = 210; / x1 hat den Wert 210 / 2 int x2 = 070; / Achtung: x2 hat den Wert 56 / Allerdings haben Konstanten auch einen Datentyp: Dieser Datentyp ist durch die Darstellung der Konstanten im Quellcode gegeben. Damit eine Konstante nicht als Ganzzahl, sondern als Fließkommazahl interpretiert wird, so muss sie einen Punkt zwischen den Vorkomma- und Nachkommastellen enthalten. Zusätzlich kann man wissenschaftliche Notation verwenden, was wir lediglich an einem Beispiel verdeutlichen wollen: 1 double pi = ; / Kommadarstellung für ~Pi / 2 double c = e8; / wissenschaftliche Notation für ~Lichtgeschwindigkeit / Man kann Stellen vor und nach dem Punkt auch weglassen, diese werden dann automatisch zu 0. Beispiel: 1 double half =.5; Anmerkung: Fließkommazahlen können ausschließlich als Darstellung zur Basis 10 angegeben werden. Führende Nullen werden bei der Angabe von Fließkommakonstanten einfach ignoriert. 14

15 2.4 Operatoren und Expressions Eine Expression in C steht für einen Teil des Codes, welcher, ganz anschaulich ausgedrückt, einen Wert hat. Eine Variable ist beispielsweise bereits eine Expression, genau wie Konstanten. Alle anderen Expressions in C entstehen aus Konstanten und Variablen durch deren Verknüpfung mittels Operatoren und Klammerung. Abstrakt ausgedrückt ordnet ein Operator einem oder mehreren Werten einen neuen Wert zu. So sind etwa alle Grundrechenarten Operator Expression Wert der Expression Addition a + b Summe von a und b Subtraktion a - b Differenz von a und b Multiplikation a * b Produkt von a und b Division a / b Quotient von a und b Modulo a % b Rest einer Ganzzahldivision von a durch b Tabelle 3: Arithmetische Operatoren sogenannte binäre Operatoren (da sie zwei Werten einen Neuen zuweisen, nämlich gerade das Rechenergebnis). Beispiele für Expressions sind 3+5*9 und (pi+5)*9. Dabei gilt wie gewohnt: Punkt- vor Strichrechnung. Der Wert der Expression ist dann natürlich das Gesamtergebnis (beim ersten Beispiel also 48 und beim Zweiten 72). Wir werden im Laufe des Kurses außer den Grundrechenarten noch viele weitere Operatoren kennen lernen. Der Wert einer Expression kann durch den Zuweisungsoperator = in einer Variablen gespeichert werden: 1 pi = (pi+5) 9; / setzt die Variable pi auf (pi+5) 9 / Der Zuweisungsoperator entspricht also nicht dem mathematischen Gleichheitszeichen, sondern wird gelesen als wird gesetzt auf. Wer sich nun fragt, warum dies ein Operator sein soll, sei gesagt, dass eine Zuweisung in C auch einen Wert hat, nämlich gerade den Wert, der zugewiesen wird. Damit ist folgender Code korrekt: 1 x = pi = x+5 9; / entspricht x = (pi=x+5 9); / Hier wird also zunächst der Wert von (x+45) in der Variablen pi gespeichert das Ergebnis dieser Zuweisungsoperation ist wiederum (x+45), welches dann nach x geschrieben wird. Man sagt auch, der Zuweisungsoperator hat einen Nebeneffekt, da er nicht nur einen Wert zurückgibt, sondern in Folge seiner Auswertung auch den Inhalt einer Speicherzelle verändert. Da jede Expression einen Wert hat, hat sie auch einen Datentyp. Gelegentlich möchte man durch Operatoren auch Expressions verknüpfen, die formal unterschiedliche Datentypen haben in diesem 15

16 Fall muss eine der Expressions in eine Expression vom anderen Typ konvertiert werden. Diesen Vorgang nennt man typecasting. In vielen Fällen, wie etwa der Verknüpfung zweier Expressions mit Ganzzahltypen, nimmt C diese Konvertierung automatisch und meistens auch so vor, wie man es sich wünscht. Möchte man dennoch manuell eine Typkonvertierung durchführen, so geschieht dies durch folgende Syntax: (DATENTYP) (EXPRESSION) Als Beispiel könne man etwa eine Fließkommazahlen in eine Ganzzahl konvertieren, indem man schreibt: 1 double pi = ; 2 unsigned n = (unsigned) pi; Die Konvertierung von Fließkommazahlen in Ganzzahlen geschieht durch Runden in Richtung 0. All dies wirft ein neues Licht auf die oben vorgestellten Rechenoperationen: Diese haben nämlich, abhängig vom Typ ihrer Argumente, eine unterschiedliche Arbeitsweise. Dividieren wir zwei Ganzzahlen, so wird eine Ganzzahldivision durchgeführt und der dabei entstehende Rest verworfen; also ergibt 1/2 den Wert 0 und 7/3 hätte den Wert 2. Durch explizites Typecasting lässt sich hier ein anderes Verhalten erzwingen schaffen: 1 unsigned x = 1, y = 2; 2 double half = (double)x/y; / nun hat half den Wert 0.5 / Dividiert man eine Ganzzahl durch eine Fließkommazahl oder umgekehrt, so wird die Ganzzahl konvertiert und man erhält das (mehr oder minder) korrekte Ergebnis der Rechnung als Fließkommazahl. Generell gilt: Verknüpfen wir eine Fließkommazahl mit einer Ganzzahl, so wird diese in eine Fließkommazahl konvertiert, und das Ergebnis ist ebenfalls eine Fließkommazahl. Es gibt nun noch einen weiteren nützlichen Rechenoperator, der bei einer Ganzzahldivision das Ergebnis verwirft und statt dessen den Rest als Ergebnis liefert: Der sogenannte Modulo-Operator, % (ein Prozentzeichen). So wäre etwa (6%5) eine Expression mit dem Wert 1. Dieser Operator funktioniert nur mit Ganzzahlen. Häufig hat man in der Programmierung Zuweisungen der Form a = a b, wobei einer der bisherigen, binären Rechenoperatoren ist. Dafür gibt es die Kurzschreibweise a = b. Ein Beispiel: a += 1 würde den Wert von a um 1 erhöhen. 16

17 Die Situation, eine Variable um zu de- oder inkrementieren, ergibt sich sehr häufig. Dafür verwendet man folgenden unären Operatoren. Operator Art Wirkung Wert der Expression a++ postfix inkrementiere a a ++a präfix inkrementiere a a+1 a-- postfix dekrementiere a a --a präfix dekrementiere a a-1 Tabelle 4: Kurzschreibweisen Anmerkung: Es gibt Expressions, welche aufgrund ihrer Nebeneffekte nicht eindeutig sind, etwa i=i+++i. Diese Expression ist syntaktisch korrekt, doch es gibt keinen offiziellen Standard für ihren Wert. Man bezeichnet solche Expressions als undefiniert. Jeder Compiler hat bei derartigen Situationen das Recht, über die weitere Verfahrensweise zu entscheiden (Er könnte etwa die Expression auf eine mögliche Art und Weise auswerten oder einen Fehler erzeugen). Man sollte solche Expressions tunlichst vermeiden. 2.5 Formalitäten: Statements und Expressions C-Programme setzen sich aus einer oder mehreren Statements zusammen. Wir haben bereits ein Statement kennen gelernt: Die Variablendeklaration. Außerdem kann man eine Expression zu einem Statement machen, indem man sie durch ein Semikolon abschließt. Ein Beispiel dafür ist die Zuweisung, die wir bereits in 2.4 kennen gelernt haben. Darüber hinaus kann man auch eine Expressionliste als Statement auswerten lassen: Dies ist eine durch Kommata separierte Liste von Expressions, welche durch ein abschließendes Semikolon zu einem Statement führt, in dem die Expressions der Reihe nach ausgewertet werden: EXPRESSION 1, EXPRESSION 2,..., EXPRESSION n; Dies scheint zunächst nicht besonders nützlich zu sein, da wir die einzelnen Expressions durch Semikolons auch einzeln zu Statements machen können im Zusammenspiel mit anderen Statements jedoch kann es sich als nützlich erweisen, mehrere Expressions als ein einzelnes Statement zusammenfassen zu können. In Wahrheit ist eine Expressionliste ebenfalls eine Expression: Das Komma ist ein binärer Operator, welcher seine beiden Argumente auswertet und den zweiten als Ergebnis liefert: Wert und Typ einer Expressionliste sind also immer Wert und Typ der letzten Expression in der Liste. Ein weiteres, bereits bekanntes Statement ist der Block, welcher einfach mehrere Statements zu einem Statement zusammenfasst: { STATEMENT 1 STATEMENT 2... STATEMENT n } 17

18 Wichtig: Variablendeklarationen sind Statements, die nicht an jeder Stelle des Quellcodes verwendet werden dürfen. Variablendeklarationen müssen immer die ersten Statements eines Blocks sein. Die Variablen, die zu Beginn eines Blocks deklariert werden, gehören in gewisser Weise zu diesem Block. Nachdem der Block endet, werden die Variablen verworfen. Darüber hinaus kann eine Variablendeklarion in einem Block eine Variable des ihn umschließenden Blocks überdecken: Das heißt, in einem Block können Variablen deklariert werden, die außerhalb des Blocks bereits existieren. Diese beiden Variablen repräsentieren in diesem Fall zwei unterschiedliche Speicherbereiche, und innerhalb des Blocks können wir nur noch diejenige Variable verwenden, welche auch im Block deklariert wurde. Ein Beispiel: 1 #include <stdio.h> 2 int main() { / Hier beginnt Block 1 / 3 int i = 4; 4 int j = 6; 5 { / Hier beginnt Block 2 / 6 int i=3; 7 printf("%i\n",i); / Gibt 3 aus / 8 printf("%i\n",j); / Gibt 6 aus / 9 } / Hier endet Block 2 / 10 printf("%i\n",i); / Gibt 4 aus / 11 } / Hier endet Block 1 / Listing 4: Beispiel für Überdeckung 2.6 If-Else-Statement Einfache Rechenoperatoren erlauben uns nicht, komplexe Algorithmen zu implementieren es fehlt die Möglichkeit, abhängig vom Ergebnis einer Operation unterschiedlichen Code auszuführen. Um dies zu ermöglichen, lernen wir nun das erste Programmierstatement kennen: Das If-Else-Konstrukt: if ( BEDINGUNG ) BEFEHL 1 else BEFEHL 2 wobei die Bedingung eine beliebige Expression und die Befehle jeweils ein beliebiges Statement (meistens ein Block) sein können. Es wird der erste Befehl ausgeführt, sofern die Bedingung einen Wert ungleich 0 hat. Ansonsten, falls durch else angegeben, der zweite. 2.7 Logische- und Vergleichsoperatoren Für die Bedingung im If-Else-Statement lernen wir noch einige weitere Operatoren kennen, die sogenannten Vergleichsoperatoren: 18

19 Operator Prüfen auf Gleichheit Prüfen auf Ungleichheit Prüfen, ob a echt größer als b ist Prüfen, ob a echt kleiner als b ist Prüfen, ob a größer oder gleich b ist Prüfen, ob a kleiner oder gleich b ist Syntax a == b a!= b a > b a < b a >= b a <= b Tabelle 5: Vergleichoperatoren Diese Operatoren liefern immer die Werte 1 oder 0, abhängig vom Ergebnis des Vergleiches. Damit wird das If-Else-Statement bereits zu einem mächtigen Werkzeug. Als Beispiel ein Codesegment, dass die Signumsfunktion für einen Eingabewert x implementiert: 1 if (x < 0) / falls x kleiner als 0 ist: / 2 y = 1; / das Signum ist 1 / 3 else / Ansonsten (falls x größergleich 0): / 4 y = (x!= 0); / falls x Null, wird y Null, sonst 1 / Listing 5: Signumsfunktion Um Vergleiche logisch zu verknüpfen, gibt es darüber hinaus auch noch die sogenannten logischen Operatoren (2.7). Dies sind ebenfalls binäre Operatoren (bis auf das logische Nicht), welche zwei Expressions die Werte 0 oder 1 zuweisen. Operator Syntax Logisches Und A && B Logisches Oder A B Logische Verneinung!A Tabelle 6: Logische Operatoren Die Ergebnisse der Logischen Operatoren lassen sich am einfachsten durch Wertetabellen veranschaulichen. Siehe dazu 2.7. A B A && B A B!A Tabelle 7: Logische Operatoren Es gibt jedoch noch eine wichtige Eigenart dieser Operatoren zu erwähnen: Die logischen Operatoren werten nur so viele ihrer Argumente aus, bis das Ergeb- 19

20 nis der Verknüpfung bereits feststeht. So würde etwa bei der Auswertung von (1 x--) die Variable x nicht dekrementiert, da das Ergebnis der Operation bereits bei der Auswertung von 1 feststeht. Dies ist selbstverständlich nur von Bedeutung, sofern eine der auszuwertenden Expressions einen Nebeneffekt hat. 2.8 Der Schleifen erster Teil: while Wollen wir einen bestimmten Codeblock mehrfach ausführen, so verwenden wir ein Statement, was als Schleife bezeichnet wird. Eine Schleife wiederholt die Befehle so lange, wie eine bestimmte Expression ungleich 0 ist. Die Syntax while (BEDINGUNG) BEFEHL weist den Computer an, zu prüfen, ob die Expression BEDINGUNG ungleich 0 ist. Ist dies der Fall, so wird das Statement BEFEHL ausgeführt und wir fangen wieder von vorne mit dem Prüfen der Bedingung an. Andernfalls wird die Schleife beendet. Meistens sollten die Befehle dafür sorgen, dass BEDINGUNG irgendwann zu 0 auswertet, indem etwa Variablen verändert werden. Man kann jedoch ebensogut eine Endlosschleife programmieren: 1 while(1); / leeres statement: tue nichts, und das für immer / Listing 6: Endlosschleife Wir wollen ein Beispiel angeben, welches die Geometrische Reihe n=0 q n = 1 1 q ausrechnet: 1 double q = 0.2; 2 double x = 1.0, y = 0.0; / Hilfsvariablen / 3 while (x > 1e 10) { / Solange x nicht zu klein ist / 4 y = y+x; / y speichert die Partialsummen / 5 x = x q; / Berechne den nächsten Summanden / 6 } 7 / Ergebnis steht jetzt in y / Listing 7: Geometrische Reihe Dieses Beispiel zeigt anschaulich, dass Programme deutlich aufwändiger sein können, als sie müssen. Wir hätten ebenso gut y=1./(1.-q); schreiben können, was der Computer in einem Bruchteil der Zeit berechnen könnte. Man sollte sich immer bemühen, nicht unnötig Rechenzeit zu vergeuden. Wenn man das Statement BEFEHL gerne Ausführen möchte, bevor das erste Mal geprüft wird, ob BEDINGUNG zu 0 auswertet, so kann man eine do-while-schleife verwenden: do BEFEHL while(bedingung); Man bemerke hier das zwingend erforderliche Semikolon am Ende. 20

21 2.9 Der Schleifen zweiter Teil: for Die while-schleife lässt sich verallgemeinern zur for-schleife, dem folgenden Konstrukt: for( INITIALISIERUNG; BEDINGUNG; STEP ) BEFEHL wobei wir dies wie folgt durch eine while-schleife modellieren könnten, sofern die Bedingung angegeben ist: INITALISIERUNG; while ( BEDINGUNG ) { BEFEHL STEP; } Damit sind also die Initialisierung, der Step und die Bedingung jeweils eine Expression. Der Befehl ist, wie immer, ein einzelnes Statement (meistens ein Code- Block). Das Beispiel aus dem letzten Abschnitt kann man also so umschreiben: 1 double x,y,q = 0.2; 2 for (x=1.,y=0.; x>1e 10; x = x q) 3 y = y+x; Listing 8: Geometrische Reihe mit einer For-Schleife Lässt man bei der for-schleife die Bedingung weg, bricht die Schleife nicht ab. Genauer: Die Schleife verhält sich so, als wäre die Bedingung die konstante Expression 1. Step oder Initialisierung sind ebenfalls optional und können weggelassen werden also ist folgende Schleife eine Endlosschleife: for(;;); Es gibt zwei besondere Statements, welche innerhalb von Schleifen verwendet werden können: Statement break; continue; Effekt Schleife abbrechen bzw. zum nächsten Statement nach der Schleife springen. In einer for-schleife wird der Step noch einmal ausgeführt. Nur diesen Schleifendurchlauf abbrechen (zum Step springen). Tabelle 8: Spezielle Schleifenbefehle Bei einer for-schleife sorgt ein continue-statement also dafür, dass der Step noch ausgeführt wird, bevor die Bedingung abgefragt wird und dann evtl. der nächste Schleifendurchlauf beginnt. 21

22 3 Funktionen Funktionen sind ein grundlegendes und wichtiges Konzept der Programmierung. Sie ermöglichen es, häufig benötigte Programmzeilen als Unterprogramm zusammenzufassen. An anderen Stellen im gleichen Programm kann man dann durch einen sogenannten Aufruf der Funktion dorthin verzweigen. In der Funktion selbst kann man durch das return - Statement dafür sorgen, dass die Ausführung an der Stelle fortgesetzt wird, an der die Funktion aufgerufen wurde. Wie ihre mathematischen Äquivalente können Funktionen Argumente erhalten und einen Rückgabewert besitzen. 3.1 Funktionsdefinitionen Eine Funktionsdefinition hat folgende Form: RÜCKGABETYP FUNKTIONSNAME( PARAMETERTYP 1 PARAMETERNAME 1, PARAMETERTYP 2 PARAMETERNAME 2,..., PARAMETERTYP n PARAMETERNAME n ) { BEFEHLE } Der Rückgabetyp ist hierbei ein beliebiger Datentyp - dieser bestimmt, welchen Datentyp der Ausdruck des Funktionsaufrufes hat. Ein Funktionsaufruf hat die Syntax: FUNKTIONSNAME ( PARAMETER 1,..., PARAMETER n ) Dies bedeutet, dass eine Funktion ein vom Programmierer neu definierter Operator ist: Sie weist einem oder mehreren Werten einen neuen Wert (den Rückgabewert) zu. Bei jedem Funktionsaufruf werden zunächst neue Variablen PARAMETERNAME 1 bis PARAMETERNAME n erstellt, welche vom in der Funktionsdefinition angegebenen Datentyp sind. Dann werden die Expressions PARAMETER 1 bis PARAMETER n ausgewertet und den Variablen in der entsprechenden Reihenfolge zugewiesen. Anschließend werden die Befehle in der Funktionsdefinition ausgeführt, bis der Wert berechnet wurde, den der Funktionsaufruf haben soll. Durch das folgende Statement beendet die Funktion sich selbst augenblicklich und legt ihren sogenannten Rückgabewert fest: Der Wert des Funktionsaufrufes. return RÜCKGABEWERT; 22

23 Die Parameter in der Funktionsdefinition sind Variablendeklarationen, deren Initialisierung durch den Funktionsaufruf statt findet. Sie gehören zum Block der Funktionsdefinition und können (sollten) dort zur Berechnung des Rückgabewerts verwendet werden Dennoch kann eine Funktion selbstverständlich zu Beginn weitere, interne Variablen erstellen. Innerhalb der Funktion sind dies aber insgesamt die einzigen Variablen, auf die direkt (mit Namen) zugegriffen werden kann. Wir wollen nun Code für eine Funktionsdefinition vorstellen, welche das Signum einer Ganzzahl ausrechnet (siehe auch 2.7) und diese Funktion dann aufrufen: 1 #include <stdio.h> 2 3 int sign( int x ) { 4 if (x < 0) return 1; 5 else return (x!= 0); 6 } 7 8 int main() { 9 printf("%i\n", sign( 5)); / Wird 1 ausgeben. / 10 return 0; 11 } Noch ein Beispiel: Listing 9: Funktionsdefinition und -aufruf 1 #include <stdio.h> 2 3 / berechnet zahl hoch exponent / 4 double potenz(double zahl, unsigned int exponent) { 5 double ergebnis; 6 for (ergebnis = 1.0; exponent; exponent ) 7 ergebnis = zahl; 8 return ergebnis; 9 } int main() { 12 printf("%f\n", potenz(0.5, 4) ); / Wird ausgeben. / 13 return 0; 14 } Listing 10: Funktion zum Berchnen ganzer Potenzen von Fließkommazahlen Wir können nun zum ersten mal feststellen, welche genaue Form ausführbarer C-Quellcode hat: Dieser setzt sich nämlich aus Funktionsdefinitionen zusammen, welche wiederum aus Statements bestehen, die bei Aufruf der Funktion in angegebener Reihenfolge ausgeführt werden. Es muss eine Funktion mit dem Namen main geben, welche zu Beginn des Programms gestartet wird. 23

24 Wir lernen an dieser Stelle noch einen neuen Datentyp kennen, den Datentyp void. Man kann keine void-variablen deklarieren, denn eine Expression mit Datentyp void hat keinen Wert. Allerdings gibt es Funktionen mit Rückgabetyp void, welche man auch als Prozeduren bezeichnet. Eine Prozedur muss kein return-statement enthalten, kann jedoch das leere return-statement return; verwenden, um sich selbst zu beenden. 1 #include <stdio.h> 2 3 void printint(int x) { 4 printf("%i\n",x); 5 } 6 7 int main() { 8 printint(42); / gebe 42 auf der Kommandozeile aus / 9 return 0; 10 } Listing 11: Beispiel für eine Prozedur 3.2 Funktionsdeklaration vs. Funktionsdefinition Möchte man eine Funktion aufrufen, so muss die Definition dieser Funktion im Quellcode vor dem Funktionsaufruf liegen, da der Compiler die aufzurufende Funktion bereits kennen muss, damit er einen Aufruf korrekt in Maschinencode übersetzen kann: Dazu muss er wenigstens wissen, wie genau die Funktionsargumente und der Rückgabetyp aussehen. Man kann diese Informationen jedoch angeben, bevor man die Funktion tatsächlich definiert, indem man lediglich eine Funktionsdeklaration verwendet. Dieses Statement sieht wie folgt aus: RÜCKGABETYP FUNKTIONSNAME( PARAMETERTYP 1 PARAMETERNAME 1,..., PARAMETERTYP n PARAMETERNAME n ); Die Deklaration enthält also nur den sogenannten Funktionskopf, in dem alle für den Compiler wichtigen Informationen enthalten sind. Nachdem die Funktion deklariert ist, kann man sie im nachfolgenden Quellcode verwenden. An irgendeiner Stelle muss allerdings dann die tatsächliche Definition stehen. Hier ein Beispiel, welches ohne dieses Sprachkonstrukt gar nicht möglich wäre: 24

25 1 #include <stdio.h> 2 3 / Funktionsdeklarationen / 4 int ungerade(int); / diese Deklaration ist notwendig. / 5 int gerade(int); / diese Deklaration nicht, ist aber huebsch. / 6 7 / Funktionsdefinitionen / 8 int gerade(int n) { 9 / testet, ob n gerade ist / 10 if (n == 0) return 1; 11 else return ungerade(n 1); / wir müssen "ungerade" kennen / 12 } 13 int ungerade(int n) { / testet, ob n ungerade ist / 14 if (n == 0) return 0; 15 else return gerade(n 1); 16 } int main() { 19 if ( gerade(5) ) { 20 printf("verkehrte Welt\n"); 21 return 1; 22 } else return 0; 23 } Listing 12: Funktionsdeklarationen sind notwendig Die Umsetzung dieser Funktionen ist natürlich haarsträubend ineffizient, umständlich und unverständlich. Wir konnten jedoch kein Besseres Beispiel für Funktionen finden, die sich auf diese Art und weise gegenseitig aufrufen: Man bezeichnet dies auch als indirekte Rekursion. 3.3 Modulares Programmieren und Linken Die Kompilierung von großen Programmen zu schnellem und effizientem Maschinencode bedarf eines deutlich merkbaren Rechenaufwands. Während der Weiterentwicklung oder Fehleranalyse solcher Programme müssen allerdings ständig Teile des Programmcodes verändert werden und es wäre zu zeitaufwändig, das gesamte Programm ständig neu zu kompilieren - insbesondere, da sich ja nur gewisse Teilbereiche des Programms ändern - etwa nur eine bestimmte Funktion. Man geht deswegen dazu über, einzelne Teile eines Programms so voneinander zu trennen, dass der Compiler sie unabhängig voneinander in Maschinencode übersetzen kann. Diese Teile nennt man auch Module. Nachdem ein solches Modul kompiliert wurde, ist es natürlich kein lauffähiges Programm - insbesondere verwendet das Modul unter Umständen Funktionen, deren Programmcode sich in anderen Modulen befindet. Um diese Abhängigkeiten aufzulösen, wird in der Schlussphase der Codegenerierung ein Programm (der Linker) gestartet, um die kompilierten Module zu einem lauffähigen Programm 25

26 zusammenzufügen. Diesen Vorgang bezeichnet man dementsprechend als Linken. Ein Modul in C ist zunächst eine Datei mit Dateiendung c. Jede solche.c-datei wird von dem Compiler zu einer sogenannten Objektdatei kompiliert, welche das kompilierte Modul darstellt. Diese Objektdatei enthält Informationen darüber, welche Funktionen das Modul enthält und welche Funktionen von dem Modul aus anderen Modulen benötigt werden. Sind einmal alle Objektdateien erstellt, löst der Linker die Abhängigkeiten zwischen ihnen auf und fügt die Objektdateien zu einem lauffähigen Programmcode zusammen. Dieser Vorgang ist unabhängig von der Kompilierung. Bei der Kompilierung ist es jedoch erforderlich, dass Funktionen definiert werden, bevor sie im Quellcode danach verwendet werden. Existiert etwa eine Quellcodedatei moremath.c, welche unter anderem eine Funktion 1 unsigned fibonacci(unsigned n) beinhaltet, so könnte man die folgende main.c natürlich trotzdem nicht erfolgreich kompilieren, da zumindest eine Deklaration der Funktion fehlt: 1 #include <stdio.h> 2 / Hier fehlt eine Deklaration oder Ähnliches / 3 int main() { 4 unsigned j; 5 for (j=1; j<10; j++) 6 printf("%u\n", fibonacci(j)); 7 return 0; 8 } Listing 13: Fehlende Deklaration Man mache sich klar, dass dies ein Problem des Compilers und völlig unabhängig vom Linker ist. Um dieses Problem zu lösen, gehört zu jedem Modul auch eine Headerdatei mit der Dateiendung h, welche den gleichen Namen wie die Quellcodedatei des Moduls erhält. Diese enthält nur Funktionsdeklarationen. Im Sinne des obigen Beispiels sähe die Headerdatei moremath.h etwa so aus: 1 unsigned faculty(unsigned n); / berechnet n! / 2 unsigned fibonacci(unsigned n); / berechnet die n te Fibonaccizahl / Listing 14: Header-Datei für das moremath-modul Also enthält die Headerdatei lediglich Informationen über die Verwendung der Funktionen, die sich im zugehörigen Modul befinden, damit eine Kompilierung mit voneinander getrenntem Code überhaupt erst möglich wird. Mit dieser Datei ist main.c in folgender Variante nun kompilierbar: 26

27 1 #include <stdio.h> 2 #include "moremath.h" 3 int main() { 4 unsigned j; 5 for (j=1; j<10; j++) 6 printf("%u\n", fibonacci(j)); 7 return 0; 8 } Listing 15: Deklaration fehlt nun nicht mehr Die Headerdateien von selbstgeschriebenen Modulen werden durch die #include - Anweisung direkt in den Quellcode eingefügt (kopiert). Die Headerdateien eigener Module werden mit Anführungszeichen angegeben, Headerdateien von Systemmodulen mit spitzen Klammern. In der Tat gibt es bereits im System vorhandene Modul wie etwa stdio und math, welche sich in ihrer Funktionsweise nicht von selbst erstellten Modulen unterscheiden. Das Modul moremath.c könnte nun wie folgt aussehen: 1 #include "moremath.h" 2 3 unsigned faculty(unsigned n) { 4 unsigned f = 1; 5 for (;n;n ) f = n; 6 return f; 7 } 8 9 unsigned fibonacci(unsigned n) { 10 if (n < 2) return 1; 11 else return fibonacci(n 1) + fibonacci(n 2); 12 } Listing 16: Das moremath-modul Die Quellcodedatei bindet für Gewöhnlich ihre zugehörige Headerdatei ein. Dies hat viele Vorteile, die in Zukunft noch klarer werden, doch einen Grund kenne wir bereits: Sollten die Funktionen eines Moduls sich gegenseitig verwenden, so vermeiden wir durch Einfügen aller Deklarationen zu Anfang Compilerfehler. Zusammenfassung: Der Compiler ist während der Kompilierung lediglich auf vollständige Deklarationen aller verwendeten Funktionen angewiesen. Diese befinden sich in den jeweiligen Headerdateien. Ist die Kompilierung abgeschlossen, muss der Linker aus einer Menge von kompilierten Modulen ein Programm erstellen. Dazu sucht er zunächst das Modul, welches die main Funktion enthält, da an dieser Stelle die Ausführung des Programms beginnen soll. Von diesem Modul ausgehend sucht der Linker nun zu jedem noch nicht verknüpften Funktionsnamen in allen Modulen (auch den Systemmodulen) nach einer Funktion mit dem gleichen Namen und bindet jenes Modul ein, sobald er es gefunden hat. Dies wird 27

28 fortgeführt, bis alle Namen aufgelöst sind und ein lauffähiges Programm erstellt werden kann. Es sei an dieser Stelle noch einmal betont, dass das Konzept von Headerdateien (.h) ein Modul auf Compilerebene beschreibt, während die Aufteilung von Funktionen auf verschiedene Quellcodedateien (.c) ein Modul auf Linkerebene beschreibt. Diese beiden Konzepte funktionieren unabhängig voneinander. Eine Headerdatei könnte etwa Deklarationen von Funktionen enthalten, die auf zwei Quellcodedateien verteilt sind, oder man könnte Deklarationen von Funktionen einer Quellcodedatei auf mehrere Headerdateien verteilen. Auch die Namen von Header- und Quellcodedatei eines Moduls müssen streng genommen nicht übereinstimmen - all dies gebietet nur der gute Stil und die Übersichtlichkeit des gesamten Projekts. 3.4 Der Präprozessor Bevor der Compiler tatsächlich mit der Kompilierung eines C-Programms beginnt, wird ein Programm aufgerufen, dass als Präprozessor bezeichnet wird. Er führt ausschließlich Textersetzungen im Quellcode durch. Er kann durch spezielle Befehle im Quellcode gesteuert werden, welche durch eine führende Raute (#) gekennzeichnet werden. Einige dieser Befehle kennen wir bereits, etwa geschieht das Einbinden von Headerdateien durch den Präprozessorbefehl: 1 #include <stdlib.h> 2 #include "myheader.h" Listing 17: Einbinden von Header-Dateien sind Präprozessoranweisungen Hier erfolgt eine reine Textersetzung - der Inhalt der Datei myheader.h wird vollständig an die Stelle des include - Befehls kopiert. Die spitzen Klammern sind notwendig, um eine Standardheader einzufügen, während Anführungszeichen verwendet werden, um selbst erstellte Header-Dateien einzufügen. Es gibt jedoch noch einige weitere nützliche Präprozessorbefehle Makrodefinition #define MAKRO REPLACE ist eine sogenannte Makrodefinition. Sie weist den Präprozessor an, die Zeichenkette MAKRO im Folgenden immer durch REPLACE zu ersetzen. Dabei kann REPLACE auch der leere String sein bzw. weggelassen werden. Dies kann etwa dazu genutzt werden, Konstanten zu definieren: 1 #define PI

29 Es gibt weiterhin die Möglichkeit, einem Makro Parameter zu übergeben, die in REPLACE verwendet werden können: 1 #define SQUARE(_x) ((_x) (_x)) Ein Auftreten von SQUARE(3) im Quellcode würde an dieser Stelle den String ((3)*(3)) einfügen. Diese Makros sollten mit Vorsicht genossen werden, da lediglich Textersetzungen durchgeführt werden. Ist etwa funct eine langsame Funktion, so führt die Verwendung von SQUARE(funct(x)) zu ((funct(a))*(funct(a))). Dies bedeutet, dass die Funktion unnötigerweise zwei mal aufgerufen wird. Ähnlich führt SQUARE(x--) dazu, dass die Variable x zwei mal dekrementiert wird. Man mag sich weiterhin wundern, warum bei der Definition von SQUARE so viele Klammern verwendet wurden, doch man führe sich einfach vor Augen, dass SQUARE(2+2) ohne die inneren Klammern durch (2+2*2+2) ersetzt würde. Es ist sinnvoll, die Parameter bei Makrodefinitionen mit einem Unterstrich zu beginnen, damit keine Konflikte mit tatsächlich vorhandenen Variablen entstehen können Bedingte Texte #if AUSDRUCK TEXT A #else TEXT B #endif Dieser Befehl erlaubt es uns, mit dem Präprozessor kleinere Fallunterscheidungen durchzuführen. Wenn die Bedingung der if - Anweisung erfüllt ist, so wird Text A eingefügt, andernfalls Text B. Der else - Zweig der Anweisung ist optional. Auf die verschiedenen Möglichkeiten für Ausdrücke lohnt es sich kaum, hier einzugehen - der wichtigste Ausdruck ist vermutlich #if defined(makroname) welcher prüft, ob ein Makro mit Namen MAKRONAME bereits definiert ist. Damit lassen sich insbesondere Inklusionskreise bei Headerdateien vermeiden: 1 #if!defined(mymath_h) 2 #define MYMATH_H 3 / Inhalt / 4 #endif Listing 18: Zirkuläre Inclusion verhindern Beim ersten Einfügen dieser Datei mittels #include wird das Makro MYMATH_H noch unbekannt sein, daher wird der Präprozessor den Text nach #if einfügen 29

30 und insbesondere das Makro MYMATH_H definieren. Sollte die Datei ein zweites mal per #include eingefügt werden, ist das Makro MYMATH_H nun definiert und der Präprozessor überspringt alles zwischen #if und #endif. Damit ist also sichergestellt, dass der Inhalt einer Headerdatei nur ein einziges Mal in einem Projekt eingefügt wird. Man nennt dieses Konstrukt auch Include Guards (Include Wächter). Es sollte nach Möglichkeit bei allen Headerdateien verwendet werden, da der Präprozessor sonst in eine Endlosschleife gerät, sobald zwei Headerdateien sich gegenseitig per #include einbinden. Da dieser Befehl überaus nützlich und weit verbreitet ist, gibt es eine Kurzschreibweise: #ifndef MYMATH_H #if!defined(mymath_h) #ifdef MYMATH_H #if defined(mymath_h) Makrodefinition löschen #undef MAKRONAME Wird verwendet, um ein bereits definiertes Makro zu löschen. Ist das angegebene Makro noch nicht definiert, hat der Befehl keine Auswirkung. 3.5 Präprozessor - Compiler - Linker: Ein Beispiel Wir wollen anhand eines bereits bekannten Beispiels (mit Bildern) den Werdegang eines Projekts aus Quellcodedateien zur fertigen, ausführbaren Datei illustrieren. Angenommen also, wir hätten das folgende Projekt: 1 #include <stdio.h> 2 #include "gmodul.h" 3 4 int main() { 5 if (gerade(5)) { 6 printf("verkehrte Welt\n"); 7 return 1; 8 } else return 0; 9 } Listing 19: main.c 1 #ifndef _UMODUL_H 2 #define _UMODUL_H 3 #include "gmodul.h" 4 int ungerade(unsigned n); 5 #endif Listing 20: umodul.h 30