Übersicht. C Modularisierung. Präprozessor, Compiler, Linker. Präprozessor, Compiler, Linker. Präprozessor, Compiler und und Linker Linker

Transkript

1 Übersicht Präprozessor, Compiler und und Linker Linker Befehle des Präprozessors C Modularisierung Bedingte Kompilierung Modulare Programmierung Prinzipien der Modularisierung 1 2 Präprozessor, Compiler, Linker Präprozessor, Compiler, Linker Übersetzungsvorgang für C und C++ Quellen Aus: Thomas Müller Einführung in C++, vdf 3 Aus: Thomas Müller Einführung in C++, vdf 4

2 Präprozessor, Compiler, Linker Präprozessor Der Präprozessor sucht in den Quelltexten nach speziellen Befehlen, um dann im wesentlichen textuelle Ersetzungen durchzuführen Der Compiler wandelt den so geänderten Code in Objektcode um, der aber noch offene Aufrufe enthält Der Linker verbindet die noch offenen Funktionsaufrufe mit den zugehörigen Funktionen Der Präprozessor hat folgende Aufgaben: Dateien in andere einfügen #include Konstanten definieren #define Makros zur Verfügung stellen #define Teile des Quelltextes selektieren #ifdef, #ifndef... und erstellt ein ablauffähiges Programm 5 6 Präprozessor Warum ein Präprozessor? Wichtig bei allen Präprozessorbefehlen ist: Sie führen Ursprünglich vor allem dazu gedacht, den Code textuelle Änderungen am Quellcode aus kompakter und lesbarer zu machen Aufruf des Präprozessors: cpp Oder: Die Option -E des gcc führt dazu, dass der Übersetzungslauf nach dem Präprozessor abgebrochen wird gcc -E... -E Stop after the preprocessing stage; do not run the compiler proper. The output is in the form of preprocessed source code, which is sent to the standard output. Leider lassen sich mit Präprozessor-Direktiven auch leicht Fehler in den Code einbauen, die schwer zu finden sind In C99 und C++ wurden einige Sprachmittel eingeführt, mit denen sich viele Präprozessor-Befehle vermeiden lassen Präprozessorbefehle werden auch Direktiven genannt 7 8

3 Compiler Weitere Aufgaben des Compilers Der Compiler bekommt den vom Präprozessor überarbeiteten Quelltext und setzt ihn in einen Objektcode um Objektcode Maschinen-Code Nicht ausführbar, da noch unaufgelöste Referenzen (z.b. Funktionsaufrufe) enthalten sind Prüfung auf syntaktische und grammatische Fehler Statische Typprüfung Teilweise Warnung für logische Fehler Anlegen von Tabellen, in denen Buch über die verwendeten Variablen geführt wird Meistens mit der Endung.o oder.obj 9 10 Linker Bibliotheken Setzt die vom Compiler generierten Objektmodule zu einem Der Linker sucht auch in speziellen Dateien, den Bibliotheken, vollständigen Programm zusammen um alle Referenzen aufzulösen Sucht nach Funktionsaufrufen und den dazugehörigen Eine Bibliothek ist eine Sammlung von Objekt-Modulen in Funktionen und überprüft, ob alle Variablen, die deklariert einer Datei wurden, auch irgendwo definiert sind Der Linker sucht in der Standard-Bibliothek nach allen Fügt Code für die nötigen Aktivitäten beim Programmstart Standard-Funktionen hinzu Sowohl für C als auch für C++ sind Standard-Bibliotheken Nach dem Linken liegt ein fertiges, ausführbares Programm vorgegeben vor Zusätzliche Bibliotheken müssen beim Linken angegeben werden 11 12

4 Übersicht Präprozessor-Befehle Präprozessor, Compiler und Linker Befehle des Präprozessors Bedingte Kompilierung Modulare Programmierung Prinzipien der Modularisierung Dateien einbinden Konstanten definieren Vordefinierte Konstanten Makros Beispiel: #include "dateiname" Bei einer Präprozessor-Anweisung muss das Zeichen "#" in der ersten Spalte der Programmzeile stehen Kein Semikolon am Ende Dateien einbinden Konstanten definieren Befehl: #include Befehl #define Zwei Varianten: Beispiel: #include <Dateiname> #define MAXLOOP #include "Dateiname" Über diese Anweisung können Ersetzungen durchgeführt werden Erste Variante für das Einbinden von Header-Dateien aus Standard-Bibliotheken Wird der Name irgendwo im Programmcode gefunden, wird an dieser Stelle der Ersetzungstext eingefügt, Zweite Variante für projektspezifische Header-Dateien ausgenommen in Zeichenketten und Kommentaren 15 16

5 Konstanten definieren Konstanten definieren Beispiel #define ANZAHL 10 /* meistens besser: */ const int ANZAHL=10; /* oder: */ enum { ANZAHL=10 }; Verwendung int feld [ANZAHL]; int j = ANZAHL; Wichtig: Der Präprozessor ersetzt diese Symbole rein textuell Auf diese Weise können durch den Präprozessor auch leicht Fehler in den Code eingebaut werden: #define I 10 int I = 20; /* wird zu: int 10 = 20; */ Konstanten abfragen Vordefinierte Konstanten Es ist nicht nötig, einem solchen Symbol auch einen Wert zuzuweisen Auch eine Definition ohne Wert kann sinnvoll sein, da abgefragt werden kann, ob ein Symbol definiert ist oder nicht FILE DATE TIME Name der Datei, die gerade übersetzt wird Datum des Übersetzungsvorgangs Uhrzeit, zu der der Übersetzungsvorgang gestartet wurde Befehle: #ifdef Test, ob Symbol definiert LINE Aktuelle Zeile der Datei, in der der Compiler sich gerade befindet #ifndef Test, ob Symbol nicht definiert STDC Erfüllt, wenn im Standard-C Modus übersetzt wird #undef Danach ist Symbol nicht (mehr) definiert cplusplus Erfüllt, wenn der Compiler im C++ - Modus ist 19 20

6 Vordefinierte Konstanten Makros /* Ausgabe der Dateiversion: */ In der #define-direktive können nach dem Namen printf("version vom %s um %s von %s\n", des Symbols auch zusätzliche Parameter in Klammern DATE, TIME, FILE ); angegeben werden /* Ausgabe der Zeile bei Fehlern: */ if (nenner == 0) { Diese können im zu ersetzenden Text wieder auftauchen, wo sie dann textuell eingesetzt werden printf("schwerer Fehler (Division durch Null) in " "%s, Zeile %s\n", FILE, LINE ); exit(1); #define MAKRO(Argl, Arg2,...) Ersetzungstext } Hinter dem Makronamen darf kein Leerzeichen folgen Makros Makros Es kann vorkommen, dass eine Anweisung nicht in Das Nummernzeichen als Zeichenfolgenoperator (#) eine Zeile passt wandelt Makroparameter (nach der Expansion) in Dann wird das Fortsetzungszeichen "\" verwendet Zeichenfolgenkonstanten um Beispiel: Beispiel: #define ALERT(meintext) \ #define STR(data) #data printf("###########################"); \ STR(hello) /* ergibt "hello" */ printf("%s", meintext); \ printf("###########################"); 23 24

7 Makros: Probleme Mit Makros ist Vorsicht angebracht, da leicht Fehler eingebaut werden können Beispiel: #define Quadrat(x) x*x Quadrat(5+3); /* ergibt 5+3*5+3 = 23 statt 64 */ Makros: Probleme Noch besser: Man sollte Funktionen vorziehen, da Fehler, die über Makros entstehen, schwerer zu finden sind In C99 und C++ können Präprozessor-Konstanten und -Makros meistens besser durch const und Inline- Funktionen realisiert werden Besser die Argumente von Makros in Klammern schreiben: #define Quadrat(x) ((x)*(x)) "Almost every macro demonstrates a flaw in the programming language, in the program, or in the programmer." (Bjarne Stroustrup) Übersicht Bedingte Kompilierung Präprozessor, Compiler und Linker Befehle des Präprozessors Bedingte Kompilierung Modulare Programmierung Prinzipien der Modularisierung Man kann den Präprozessor auch dazu nutzen, Teile des Quelltextes zu selektieren 1. Verhindern einer mehrfachen Kompilierung 2. Selektieren von Debugging-Code 3. Plattform übergreifende Programmierung Präprozessorbefehle für diese Funktionen: #ifdef und #ifndef Beide werden mit #endif abgeschlossen Nach #else kann ein Alternativzweig angegeben werden 27 28

8 Mehrfache Übersetzung Mehrfache Übersetzung Beim Einbinden von Quelltexten (meist Header-Files) mit #include muss verhindert werden, dass gleiche Dateien mehrmals eingefügt werden Grund: Mehrfache Definitionen sind nicht zulässig Dateikennung ist ein Kürzel, das in der Regel aus dem Dateinamen zusammengesetzt wird Aus Dateinamen wie "MeineDatei.h" wird zum Beispiel eine Dateikennung wie "MEINEDATEI_H" Dazu wird folgende Struktur verwendet (im Header File): #ifndef Dateikennung #define Dateikennung // Code #endif #ifndef MEINEDATEI_H #define MEINEDATEI_H // Code #endif Selektieren von Debugging-Code Selektieren von Debugging-Code Einfache Möglichkeit, zusätzlichen Code zur Fehlersuche mit in den Quelltext aufzunehmen, um ihn je nach Bedarf mit übersetzen zu lassen oder nicht #ifdef DEBUG #define DEBUG(code) code Anweisungen werden nur in den übersetzten Code übernommen, wenn die Konstante beim Präprozessorlauf definiert ist #else #define DEBUG(code) /* - */ #endif Die Konstante kann dann am Anfang des Programmcodes oder über eine Option beim Compileraufruf definiert DEBUG( printf("initialisierung abgeschlossen.\n"); ) werden Beim g++: -Dname bzw. -Dname=wert 31 32

9 Ersatz für Kommentare Plattform übergreifend Gelegentlich werden Präprozessor-Direktiven auch Quelltext für mehrere Prozessoren, Betriebssysteme, verwendet, um Code auszublenden (ohne Konflikt graphische Oberflächen o.ä. gleichzeitig zur Verfügung mit Kommentaren) stellen #ifdef GCC #ifdef UNDEF /* systemspezifischer Code für GNU-Compiler */ /* DIESER TEIL IST VORUEBERGEHEND NICHT AKTIV */ dosomething(); /* Hier ist ein Kommentar */ #endif /* UNDEF */ #endif #ifdef sun /* systemspezifischer Code für Sun-Compiler */ #endif #ifdef _MSC_VER /* systemspezifischer Code für Visual-Studio */ #endif Übersicht Modulare Programmierung Präprozessor, Compiler und Linker Befehle des Präprozessors Bedingte Kompilierung Ziele Gleichzeitige Bearbeitung durch mehrere Entwickler Nach Änderungen müssen nur Teile eines Projekts neu übersetzt werden Modulare Programmierung Prinzipien der Modularisierung Sichtbarkeit von Funktionen und Variablen Teile eines Projekts können in anderen Programmiersprachen geschrieben werden Aufteilung in Source- und Headerfiles Klare Strukturierung des gesamten Programms Bibliotheken Verbesserung der Wiederverwendbarkeit Namensräume Das make-utility 35 36

10 Sichtbarkeit Sichtbarkeit von Funktionen Die Module bilden eine Grenze für die Sichtbarkeit der definierten Funktionen und Variablen Modul C Source-Datei und die mit #include eingefügten Deklarationsdateien Funktionen können nur auf der äussersten Ebene eines Moduls definiert werden Standardmässig gilt eine Funktion als global das bedeutet, dass ihr Name an den Linker weitergegeben wird Eine Einschränkung der Sichtbarkeit auf das aktuelle Modul ist mit Hilfe des Schlüsselworts static möglich int globalfunct(int a) {... } /* fuer alle */ static int lokalfunct(int a) {... } /* nur hier */ Sichtbarkeit von Variablen Source- und Headerfiles Standardmässig sind alle Variablen global, die auf der äussersten Ebene definiert werden Soll in einem anderen Modul die Funktion globalfunct verwendet werden, muss diese dort mit Hilfe eines Eine Einschränkung der Sichtbarkeit ist ebenfalls Prototypen deklariert werden mit Hilfe des Schlüsselworts static möglich Dasselbe gilt für die globale Variable globalvar auch sie muss im anderen Modul vor der ersten Verwendung int globalvar; // fuer alle deklariert werden static int localvar; // nur hier Dafür wird das Schlüsselwort extern verwendet extern int globalvar; /* Deklaration */ 39 40

11 Source- und Headerfiles Source- und Headerfiles Die Deklarationen werden in so genannten Header Files durchgeführt /* --- Deklaration A */ Header Files sind Deklarationsdateien die sowohl ins definierende als auch ins aufrufende Modul eingebunden werden /* Datei: modul_a.h */ #ifndef MODUL_A_H #define MODUL_A_H Header Files können so als Schnittstellenbeschreibung eines Moduls verwendet werden extern int globalvar; /* fuer alle */ int globalfunct(int a); /* fuer alle */ Weitergabe eines Moduls: Implementierung kompiliert möglich (Object File) und Header File im Quelltext #endif Source- und Headerfiles Source- und Headerfiles /* --- Modul A */ /* --- Modul B */ #include "modul_a.h" #include "modul_a.h" /* Definitionen */ /* Aufruf der Funktion aus Modul A */ int globalfunct(int a) {... } /* fuer alle */ int result = globalfunct(42); static int lokalfunct(int a) {... } /* nur hier */ /* Zugriff auf die Variable aus Modul A */ int globalvar = 24; /* fuer alle */ int var = globalvar; static int localvar; /* nur hier */ 43 44

12 Bibliotheken Bibliotheken Bibliotheken lassen sich mit speziellen Tools aus Programm zum Erzeugen von Bibliotheken: ar Objektdateien bilden Objektdateien und Name der zu erstellenden Sie stellen dem Linker komplette Funktionen zur Bibliothek werden übergeben Verfügung, die dieser bei Bedarf mit in Programme einbinden kann Bibliothek wird zusammen mit anderen Bibliotheken so abgelegt, dass sie vom Linker gefunden werden Es wird eine Header-Datei erstellt, die Prototypen der öffentlichen Funktionen der Bibliothek enthält Bibliothek verwenden Diese Header-Datei wird so abgelegt, dass der Präprozessor sie findet Header File der Bibliothek einfügen (#include) Funktionen und Variablen der Bibliothek verwenden Bibliothek mit dem Programm linken Das make-utility Das make-utility Jedes etwas grössere Programm setzt sich aus einer Das Utility make hilft dabei, ein Programm aus mehreren ganzen Reihe von Dateien zusammen Modulen unter Berücksichtigung der Abhängigkeiten zu Schon bei Veränderungen einer Datei kann es nötig sein, erstellen mehrere Module neu zu übersetzen Hinweis: Das frei verfügbare und im Funktionsumfang Wird z.b. ein Header-File verändert, so sollten alle Quelltextfiles, die dieses Header-File einbinden, neu bedeutend erweiterte GNU-Make trägt meist den Namen gmake übersetzt werden Beim Aufruf arbeitet make die Regeln einer im aktuellen Bei grossen Projekten kann das schnell sehr Verzeichnis liegenden Makefile-Datei ab unübersichtlich werden 47 48

13 Makefile Makefile Ein Makefile enthält die Regeln, wann, was und wie es auszuführen ist Es besteht aus: Kommentaren, beginnend mit # Direktiven Variablendefinitionen Expliziten Regeln Eine Regel ist wie folgt aufgebaut: target: dependencies <TAB> command Target: Was zu erstellen ist Dependencies: Legen fest, wann das zu geschehen hat, nämlich wenn eines von ihnen jünger ist als target Command: Ist das oder die abzuarbeitenden Kommandos; wichtig ist der Tabulator am Zeilenanfang Da als dependencies auch andere targets angegeben werden können ist eine Verschachtelung der Regeln möglich Makefile Beispiel Makefile Beispiel Das Programm rechner wird aus den Modulen main.o, add.o, sub.o, mul.o sowie div.o gebildet # Ausschliesslich explizite Regeln # Alle Quelltextfiles nutzen das gemeinsame Headerfile def.h # rechner wird aus den Objektfiles (.o) zusammengebaut: rechner: add.o sub.o mul.o div.o main.o cc -o rechner add.o sub.o mul.o div.o main.o Nach Änderungen an def.h sollten also auch alle Quelltextfiles neu übersetzt werden. # clean: rm -f *.o rechner Forts

14 Makefile Beispiel Makefile Beispiel # Und so entstehen die.o-files (def.h sowie Makefile # werden angegeben, um auch bei Veraenderungen daran # die Übersetzung zu starten): add.o: add.c def.h Makefile cc -c add.c sub.o: sub.c def.h Makefile cc -c sub.c mul.o: mul.c def.h Makefile cc -c mul.c div.o: div.c def.h Makefile cc -c div.c Mit Hilfe von Variablen lassen sich Regeln einfacher ändern (vor allem, wenn sie an mehreren Stellen benötigt werden) Beim Aufruf von make lassen sich auch Variablenzuweisungen übergeben diese haben höhere Priorität als die Festlegungen im Makefile Man muss nicht alle Regeln und Variablen angeben make verwendet dann seine Voreinstellungen Makefile Beispiel Übersicht # Variante mit Variablen, impliziten Regeln und # gmake's Pattern-Regeln OBJS = add.o sub.o mul.o div.o main.o CC = gcc CFLAGS = -g rechner: $(OBJS) $(CC) $(CFLAGS) -o rechner $(OBJS) clean: rm -f *~ *.o rechner $(OBJS): %.o: %.c def.h Makefile $(CC) $(CFLAGS) -c $< -o $@ Inference Rule: xyz.o depends on xyz.c, def.h and Makefile The source file of the current dependency Full name of the current target Präprozessor, Compiler und Linker Befehle des Präprozessors Bedingte Kompilierung Modulare Programmierung Prinzipien der Modularisierung 55 56

15 Prinzipien der Modularisierung Ziele Geringe Vernetzung (wenig Schnittstellen) Schwache Kopplung (schmale Schnittstellen) Hohe Kohäsion (inhaltliche Einheit) Explizite Schnittstellen (Kommunikation mit Parameterübergabe) Information Hiding (Verstecken der Implementationsdetails) 57