Programmübersetzung & modulare Programme INE2 M. Thaler, Office TG208

Transkript

1 Programmübersetzung & modulare Programme INE2 M. Thaler, Office TG

2 slide Um was geht es? C-Quellprogramm ausführbarer Code #include <stdio.h> Quellecodedatei Headerdatei int main(void) { printf("hello World\n"); } Präprozessor C Compiler Schritt 1 Schritt 2 Objektdatei Bibliotheken Linker Schritt 3 Ausführbares Programm Loader Schritt 4 2

3 ... um was geht es? Modulare Programmierung mehrere, verschiedene Quellen main.c add.h add.c sub.h sub.asm entsprechende "Compiler" Compiler Compiler Assembler "kompatibler" Object-Code main.o add.o sub.o Linker (Binder) Linker Libraries ausführbarer Code prog.exe 3

4 Lernziele Sie können die ersten 3 Schritte der Programmübersetzung aufzählen und erklären den 4. Schritt (Loader) erklären die wichtigsten Präprozessor-Direktiven aufzählen und sie korrekt anwenden Mehrfach-Includes bei Header-Files verhindern Vorteile und Prinzipen der modularen Programmierung aufzählen erklären was ein Modul ist das Prinzip des Information-Hiding erklären und in C-Programmen anwenden C-Programme in Module aufteilen 4

5 Inhalt C-Programmübersetzung Modulare Programmierung mit C C-Präprozessor 5

6 Leseempfehlung Kapitel 8 Eigene Header Wikibooks: C Programmierung Kapitel 17 Präprozessor Wikibooks: C Programmierung Kapitel 10 Präprozessor-Direktiven 6

7 slides Schritte der Programmübersetzung Schritt 1: Präprozessor textuelle Vorverarbeitung von Direktiven Schritt 2: Compiler erzeugt Objektcode: linkbare Einheiten von Maschinencode enthält noch offene Referenzen (z.b. Funktionsaufrufe) Schritt 3: Linker fügt linkbare Einheiten zu ausführbarem Maschinencode zusammen und bindet statische Bibliotheken ein löst offene Referenzen auf (Funktionen und externe Variablen) Schritt 4: Loader lädt Programm und falls notwendig dynamische Bibliotheken startet Ausführung des Codes bei main() 7

8 Schritt 1: Präprozessor Führt Direktiven aus Definition von Konstanten, z.b. #define ANZAHL 10 Einbezug weiterer Quellen, z.b. Header Files Ein- / Ausblenden von Blöcken, z.b. Debug Code Header Files Dateien mit Endung ".h" System Header Files, z.b. #include <stdio.h> - Deklaration von Betriebssystem- und Bibliotheksfunktionen - z.b. stdio.h, math.h, stdlib.h, string.h... eigene Header Files, z.b. #include "myinclude.h" - Modularisierung der eigenen Programme 8

9 Schritt 2: Compiler Übersetzt Quellcode Object-Code Module Quellcode Dateien mit Endung ".c" Prüfung auf syntaktische und grammtische Fehler statische Typenprüfung falls möglich: Warnung bei logischen Fehlern Object-Code Maschinen-Code nicht ausführbar, enthält unaufgelöste Referenzen z.b. Funktionsaufrufe aus anderen Modulen oder auf Bibliotheksfunktionen Dateien meist mit Endung ".o" oder ".obj" 9

10 Schritt 3: Linker Object-Code Module ausführbarer Code fügt Module zusammen und bindet Bibliotheken ein ersetzt offene Referenzen, z.b. Funktionsaufrufe überprüft, ob deklarierte Variablen auch definiert sind Linking Varianten statisch der Code von Bibliotheken wird direkt in den ausführbaren Code eingebunden dynamisch der Code von Bibliotheken wird als externe Referenz vermerkt und später beim Laden (Loader) aufgelöst Bibliotheken in C eine Sammlung von Funktionen Standard-Bibliotheken werden automatisch eingebunden weitere Bibliotheken müssen beim Linken angegeben werden 10

11 Schritt 4: Loader Lädt ausführbaren Code in Speicher, startet ihn lädt ".exe" File lädt bei Bedarf dynamische Bibliotheken - bei Windows ".dll" springt zur Funktion "main()" 11

12 Modulare Programmierung Bis jetzt Programm eine einzige C Quellcodedatei Probleme - eine Datei nur ein Entwickler - unübersichtlich bei grösseren Programmen - keine Wiederverwendung von Funktionen - bei Änderungen gesamtes Programm übersetzen - etc. Neu Programm mehrere Quellcode- und Headerdateien Quellcode- und Headerdatei Modul 12

13 Modul Modul: abgeschlossen funktionale Einheit bündelt logisch zusammengehörige Funktionen, Daten und Datenstrukturen kann von Programmen und anderen Modulen genutzt werden kann als Einheit übersetzt werden trennt Schnittstelle und Implementation Beispiel: einfache Roboteranwendung Module, z.b. - Motorsteuerung - Sensorverarbeitung - Steuerlogik 13

14 Modulare Programmierung: Vorteile / Ziele Vorteile / Ziele ermöglicht Team Work - gleichzeitige Bearbeitung durch mehrere Entwickler möglich klare Strukturierung von Programmen - einfache Wiederverwendung von Modulen unabhängige Verifkation von Modulen - verbesserte Zuverlässigkeit Module in verschiedenen Programmiersprachen - z.b. C und Assembler nur geänderte Module neu übersetzen - verkürzt Compilationszeit ermöglicht Bibliotheken - re-use statt re-invertion 14

15 Prinzipien der Modularisierung Geringe Vernetzung der Module wenige Schnittstellen Schwache Kopplung zwischen Modulen schmale Schnittstellen Hohe Kohäsion innerhalb Modul hohe inhaltliche Einheit zuständig für eine wohldefinierte Aufgabe Explizite Schnittstellen Kommunikation mit Parameterübergabe Information Hiding Verstecken der Implementationsdetails trennt Schnittstelle und Implementation 15

16 slide Modulare Programmierung: Beispiel Quellcode in mehrere Module aufteilen jedes Modul eine eigene Datei und eine Header Datei Beispiel einfaches Programm: ein #define und eine Funktion addmax() main.c #include <stdio.h> #define MAX 1000 int addmax(int b); /* Funktionsdeklaration */ int main(void) { printf("%d\n", MAX + addmax(10)); } 16 int addmax(int b) { /* Funktionsdefinition */ return MAX + b; }

17 ... Beispiel 1. Schritt: Aufteilung in 2 Dateien (Module) main.c #include <stdio.h> #define MAX 1000 int addmax(int b); /* Funktionsdeklaration */ int main(void) { printf("%d\n", MAX + addmax(10)); } addmax.c 17 #define MAX 1000 int addmax(int b); /* Funktionsdeklaration, optional: wird in diesem Modul nicht aufgerufen */ int addmax(int b) { /* Funktionsdefinition */ return MAX + b; } Vorteile / Nachteile?

18 slide... Beispiel 2. Schritt: Verwenden einer Headerdatei addmax.h main.c addmax.c 18 #ifndef ADDMAX_H #define ADDMAX_H #define MAX 1000 int addmax(int b); /* Funktionsdeklaration */ #endif #include <stdio.h> #include "addmax.h" int main(void) { printf("%d\n", MAX + addmax(10)); } #include "addmax.h" int addmax(int b) { /* Funktionsdefinition */ return MAX + b; }

19 ... Beispiel 3. Schritt: Übersetzen Quellcodedateien für sich allein übersetzen Objektdateien Linker fügt Objektdateien zu ausführbarem Code zusammen main.c Compiler main.o addmax.h addmax.c Compiler addmax.o Linker Libraries main.exe 19

20 slide Modularisierung: Information Hiding Sichtbarkeit von Funktionen in C Modulen C Funktionen standardmässig global - d.h. ausserhalb des Moduls (für den Linker) sichtbar Einschränkung der Sichtbarkeit auf aktuelles Modul - Schlüsswort static int globalfunc(int a) { // für alle sichtbar... } static int lokalfunc(int b) { // nur im Modul sichtbar... } 20

21 ... Modularisierung: Information Hiding Sichtbarkeit von Variablen in C Modulen Variablen, definiert auf äusserster Ebene, sind standardmässig global sichtbar Einschränkung der Sichtbarkeit auf aktuelles Modul - Schlüsswort static int globalvar; // für alle sichtbar static int lokalvar; // nur im Modul sichtbar 21

22 C Präprozessor Wieso? ursprünglich um Code kompakter und lesbarer zu machen - z.b. Definition globaler Konstanten, etc. Achtung: fehleranfällig, Fehler schwierig zu finden Was? macht textuelle Änderungen am Quellcode unabhängig von C - kann für jede Programmiersprache verwendet werden gesteuert über Direktiven Wie? ist heute Teil jedes C Compilers kann auf Kommandozeile aufgerufen werden - z.b. Linux/GNU: gcc -E file 22

23 slide... C Präprozessor 3 wesentliche Aufgaben Dateien einfügen Makros ersetzen bedingte Übersetzung Direktiven #include #define #ifdef, #ifndef, #endif Direktiven zeilenorientiert - beginnen mit einem Hash "#" - kein Semikolon ";" am Schluss Beispiel #include <stdio.h> #define ANZAHL int maxzahl = ANZAHL; 23

24 Präprozessor: Dateien einbinden Direktive #include #include <datei> #include "datei" Funktionalität - Inhalt von Datei (Text) wird "as is" eingefügt Varianten <...> Einbinden von Header-Dateien aus Standardverzeichnissen "..." Einbinden von Dateien aus aktuellem Verzeichnis Einsatz - meistens verwendet um Konstanten und Deklarationen von Typen und Funktionen einzubinden 24

25 ... Dateien einbinden Beispiel #include "mydefinitions.h" /* print an interger */ void printinteger(int integer); int main(void) { for (int i = 0; i < NUM; i++) printinteger(i); } C Präprozessor /* print an interger */ void printinteger(int integer); 25 int main(void) { for (int i = 0; i < NUM; i++) printinteger(i); }

26 Präprozessor: Konstanten und Macros Direktive #define #define MACRO_NAME Ersatztext #define MACRO_NAME(X) Ersatztext mit Parameter X #define MACRO_NAME(X,Y,...) Ersatztext, mehrere Parameter a) b) Funktionalität a) ohne Parameter Definition von Konstanten MACRO_NAME wird durch Ersatztext ersetzt Ersatztext darf fehlen definiert MACRO_NAME (~Flag) b) mit Parameter Definition von Funktionalität (inline Code) Parameter (X) bei Aufruf durch neuen Parameter ersetzt Konvention: Macro-Namen gross schreiben Hinweis: Makro-Namen in String-Literalen werden nicht ersetzt 26

27 ... Macros Beispiel #define ANZAHL 100 #define MAL3(X) (3*X) int main(void) { for (int i = 0; i < ANZAHL; i++) printf("zahl: %d\n", MAL3(i)); } C Präprozessor int main(void) { for (int i = 0; i < 100; i++) printf("zahl: %d\n", (3*i)); } 27

28 ... Macros Achtung: Probleme es können leicht Fehler eingebaut werden Beispiel: Macro für Quadratberechnung #define QUADRAT(X) X*X... q = QUADRAT(3+5);!... q = QUADRAT(3+5*3+5); q = 8 2 = 64 q = 3 + 5*3 + 5 = 23 Regel 1 Argumente mit Klammern: #define QUADRAT(X) ((X)*(X)) Regel 2 falls möglich, Macros vermeiden Funktion verwenden 28

29 ... Macros Lange Zeilen Präprozessor arbeitet Zeilenorientiert falls Zeile zu lang - Zeile auspalten - Fortsetzungszeichen '\' verwenden Beispiel #define ALARM(text) \ printf("******* "); \ printf("%s", text); \ printf("******* "); 29

30 ... Macros printf("dieses C-File heisst %s\n", FILE ); Vordefinierte Konstanten FILE DATE TIME LINE STDC cplusplus cdelc Name der gerade übersetzten Datei Datum der Übersetzung Uhrzeit Start Übersetzung Nummer der Zeile, die übersetzt wird gesetzt, wenn im Standard C Mode übersetzt mit C++ Compiler übersetzt C Aufruf-Konvention verwenden 30 zwei "underline"

31 slide Präprozessor: bedingte Übersetzung Wieso bedingte Übersetzung? verhindern von mehrfach-includes Debugging Code ein/-ausschalten plattformübergreifende Programmierung - verschiedene Prozessoren - verschiedene Betriebssysteme Lösung auf Präprozessorebene mit Hilfe von "definierten Symbolen" (~Flag) #define DEBUG definiert Symbol DEBUG ohne Wert zuzuweisen 31

32 ... bedingte Übersetzung Symbole (MACRO_NAME) ob ein Symbol definiert ist, kann abgefragt werden Definition ohne Wert ähnlich wie boolean Direktiven ist Symbol definiert? ist Symbol nicht definiert? Definition löschen alternativer Zweig bedingten Block abschliessen Beispiel #ifdef SYMBOL #ifndef SYMBOL #undef SYMBOL #else #endif #ifdef DEBUG printf("debugging is on\n"); #endif nur übersetzt, wenn DEBUG gesetzt 32

33 ... bedingte Übersetzung Mehrfach-Includes möglich beim Einfügen von Header-Files Datei a.h #include "def.h" Datei b.h #include "def.h" #include "a.h" #include "b.h"... Datei main.c Datei main.c Code aus "def.h" Code aus "def.h" nicht zulässig 33

34 ... Mehrfach-Includes Lösung ganze Header-Datei als bedingten Block definieren Symbol für Bedingung aus Dateinamen zusammensetzen Beispiel Datei meine_defs.h #ifndef MEINE_DEFS_H #define MEINE_DEFS_H // Code der Header-Datei #endif Mehrfach-Includes #ifndef MEINE_DEFS_H #define MEINE_DEFS_H // Code der Header-Datei #endif Symbol definiert #ifndef MEINE_DEFS_H #define MEINE_DEFS_H // Code der Header-Datei #endif 34

35 Präprozessor: Debugging Code Zusätzlicher Code zur Fehlersuche nur bei Bedarf übersetzen #ifdef DEBUG printf("initialisierung fertig\n"); #endif Debug Symbol beim gcc auf der Kommandozeile angeben, z.b.: gcc -DDEBUG oder gcc -DDEBUG=Wert bei IDEs meist in Projektoptionen 35

36 Zusammenfassung Modularisierung Wichtig Headerfile (.h) - enthält alle Deklarationen eines Moduls, die für den Nutzer des Moduls zur Compilation notwendig sind - eigene Datentypen, Funktionsprototypen, etc. Implementationsfile (.c) - enthält die Definition (Implementation) des Moduls - wird in ein Objektfile (.o,.obj) übersetzt Linker - fügt die Objektfiles sämtlicher Module zu ausführbarem Programm zusammen 36