Laborübung aus Systemnahe Programmierung

Transkript

1 Laborübung aus Systemnahe Programmierung C - Block für Fortgeschrittene Roman Obermaisser Institut für Technische Informatik 2008 Systemprogrammierung C-Block 1

2 Übersicht Strukturen Eigene Typen Funktionen Werte- vs. Variablenparameter Returnwerte Modulare Programmierung in C Funktionszeiger Systemprogrammierung C-Block 2

3 Strukturen (I) Zusammenfassung mehrere Elemente verschiedenen Typs Definition struct datum { }; int ntag; int nmonat; long njahr; Verwendung (Definition von Variablen) struct datum sgeburtstag; Systemprogrammierung C-Block 3

4 Strukturen (II) Zugriff über Variablenname und Name des Strukturelements sgeburtstag.ntag = 15; Definition mit Initialisierung möglich struct datum sgeburtstag = {15, 2, 1972}; Systemprogrammierung C-Block 4

5 Eigene Typen - typedef Definition typedef struct { int ntag; int nmonat; long njahr; } Datum; Verwendung Datum sgeburtsdatum = {15, 2, 1972}; Systemprogrammierung C-Block 5

6 Funktionen (I) Funktionsdefinition <Return Typ> <Name>(<Argumentdeklaration>) double Wurzel(double fzahl, double forder) { } Aufruf einer Funktion <Name>(expression, expression,...); double nreturn = 0; nreturn = Wurzel(100, 2); Systemprogrammierung C-Block 6

7 Werteparameter (I) Übergabe aller Argumente als Werteparameter! Kopie der Argumente auf Stack Stack int sum(int day, int month, { } int year) return (day + month + year); &day &month &year Systemprogrammierung C-Block 7

8 Werteparameter (II) Argument in Funktion als lokale Variable nutzbar Veränderung des Wertes der Argumente hat keine Auswirkung auf aufrufende Funktion void Funktion1(int nzahl) { } : nzahl = 42; int na = 13; Funktion1(nA); /* na hat immer noch den Wert 13 */ Systemprogrammierung C-Block 8

9 Variablenparameter (I) Adresse der Argumente als Werteparameter übergeben! Kopie eines Zeigers auf die Variable auf dem Stack Zugriff auf Inhalt der Variable durch dereferenzieren void neg(int *x) { } *x = -(*x) Stack 15 &a &x Systemprogrammierung C-Block 9

10 Variablenparameter (II) Veränderung des Wertes der Argumente hat Auswirkung auf aufrufende Funktion void Funktion1(int *nzahl) { *nzahl = 42; } : int na = 13; Funktion1(&nA); /* na hat nun den Wert 42 */ Systemprogrammierung C-Block 10

11 Variablenparameter (III) Auch Zeiger selbst können Variablenparameter sein Zeiger kann verbogen werden int strtol(const char * nptr, char ** eptr, int base); Achtung bei Strings und ähnlichen Konstrukten Wenn nur der Inhalt veränderbar sein soll reicht ein char * char *strcpy(char * s1, const char * s2); Wenn der Zeiger verbogen werden soll: char **eptr bei strtol Oktober 2005 Systemprogrammierung C-Block 11

12 Beispiel Returnwerte (I) Zu verwendende Funktion: #include <stdlib.h> long int strtol(const char *toconvert, const char **eptr, int base); Beispiele möglicher Inputwerte für toconvert: 3...korrekt AAAA...falsch /* keine gült. Zahl */ 43BBBB...falsch /* nur part. konv. */ falsch /* nur ganzzahlig */...falsch /* leerer Input */ falsch(?) /* 2^32: hw-dep */ Systemprogrammierung C-Block 12

13 Funktionen (II) Funktionsdeklaration <Return Typ> <Name>(<Argumentdeklaration>); korrekte Verwendung von Funktionen wird beim Compilieren geprüft (Typüberprüfung) Referenz auf eine Funktion die anderswo definiert ist Funktionsdeklarationen aller exportierten Funktionen eines Moduls für andere Module in einem h-file zusammenfassen. Systemprogrammierung C-Block 13

14 Beispiel Definition versus Deklaration modula.c: Definition int Funktion1(char * szstring) {... } const char * szprogramname = <not yet set> ; modula.h: Deklaration extern int Funktion1(char * szstring); extern const char * szprogramname; Systemprogrammierung C-Block 14

15 Beispiel Returnwerte (II) Programmstück mit Fehlerabfrage: #include <stdlib.h> char *eptr, *toconvert; long value; errno = 0; value = strtol(toconvert, &eptr, 10); if ((eptr==toconvert) (*eptr!= \0 )) { /* fehlerhafter string */ } if (errno==erange) { /* overflow */ } /* (errno==einval) fehlt, da input hardcoded */ Systemprogrammierung C-Block 15

16 Modulare Programmierung (I) Warum? Klare Strukturierung, Information Hiding Übersichtlichkeit und Verständlichkeit Wiederverwertung von Code Erleichterte Wartbarkeit Systemprogrammierung C-Block 16

17 Modulare Programmierung (II) Wie? Headerfiles (*.h) Implementierungsfiles (*.c) Libraries (*.a, *.so) Kontrollierter Export (static) Systemprogrammierung C-Block 17

18 Modulare Programmierung (III) Headerfile Deklariert globale Variablen und Funktionen die vom Implementierungsfile exportiert werden (extern) Definiert Strukturen, eigene Typen und Konstanten, (die von den exportierten globalen Variablen und Funktionen benötigt werden) Schutz vor mehrfachen Einbindens (#ifndef) Systemprogrammierung C-Block 18

19 Modulare Programmierung (IV) Implementierungsfile (eigenes Modul) Definiert globale Variablen und Funktionen Bindet Headerfile ein (#include) Typkonsistenz zwischen Header und Implementierung Definiert interne Strukturen, interne eigene Typen, interne Konstanten Definiert interne Variablen und interne Funktionen (static) Systemprogrammierung C-Block 19

20 Modulare Programmierung (V) Implementierungsfile (anderes Modul) Bindet Headerfile ein (#include) Deklaration der importierten Var., Funktionen,... Verwendet importierte Var., Funktionen, Beispiel Modul1 (modul1.c und modul1.h) stellt Funktionen, Variablen, usw. zu Verfügung Modul2 (modul2.c) verwendet diese Systemprogrammierung C-Block 20

21 Modul 1 Headerfile (modul1.h) #ifndef MODUL1_H_ #define MODUL1_H_ #define Y2K 2000 typedef struct { } Datum; extern Datum sgeburtstag; extern int equal(datum x, Datum y); #endif /* MODUL1_H_ */ Systemprogrammierung C-Block 21

22 Modul 1 Implementierungsfile (modul1.c) #include modul1.h Datum sgeburtstag; /* exportiert */ static Datum stag; /* nicht exportiert */ int equal(datum x, Datum y) /* exportiert */ { } static void foo(void) /* nicht exportiert */ { } Systemprogrammierung C-Block 22

23 Modul 2 Implementierungsfile (modul2.c) #include modul1.h static void foo(void) /* eigene Funkt. foo */ { Datum snamenstag; } if (equal(snamenstag, sgeburtstag)) { /* so ein Zufall */ } Systemprogrammierung C-Block 23

24 Vom Sourcecode zum Executable modul1.c modul1.h modul2.c Source Files Compiler modul1.o modul2.o Object Files Linker programm Executable Systemprogrammierung C-Block 24

25 Funktionszeiger (I) Zeiger auf Funktionen Anwendungen Dynamisches Verändern des Programmverhaltens Verallgemeinerung von Algorithmen (qsort(3)) Installation von Signalbehandlungsroutinen (signal(2)) Umsetzung objektorientierter Programmierung (virtual) Definition struct bar (*pfunction1)(int, char); Typ Definition erhöht Lesbarkeit typedef struct bar (*FuncPtr)(int, char); FuncPtr pfunction2; Systemprogrammierung C-Block 25

26 Funktionszeiger (II) Verwendung void (*pfunction1)(int);... void foo(int x) {... }... pfunction1 = foo;... (*pfunction1)(42); Systemprogrammierung C-Block 26

27 Funktionszeiger (III) Signalbehandlung #include <signal.h>... void foo(int x) { } (void) signal(sigint, foo); Systemprogrammierung C-Block 27

28 Literatur C-Programmierung Buch Systemnahe Programmierung Unix Manualpages The C Programming Language (B. Kernighan und D. Ritchie, Prentice Hall) C - A Software Engineering Approach (Springer Verlag) Programmiertechniken Writing Solid Code (S. Maguire, Microsoft Press) Systemprogrammierung C-Block 28