Übung zu Grundlagen der Betriebssysteme. 2. Übung

Transkript

1 Übung zu Grundlagen der Betriebssysteme 2. Übung

2 Termine Übungen 1. Übungsblatt Abgabe: kommenden Freitag (26.10.), 16 Uhr über SVN der Gruppe: gruppenname notfalls: Gruppenanmeldung: 2

3 Inhalte der Übung C Pointer (Zeiger) Funktionen Header Dateien Makefile Input/Output Debugging

4 C von A bis Z Jürgen Wolf online verfügbar

5 Adressoperator #include <stdio.h> int main (void) { int i; /* ein ganzzahliger Datentyp */ printf("bitte geben Sie eine Zahl ein : "); scanf("%d", &i); /* Wartet auf die Eingabe. */ printf("die Zahl, die Sie eingegeben haben, war %d\n",i); return 0; gcc o hello hello.c

6 Addressoperator gibt Adresse der Variable zurück scanf("%d", &i); /* Wohin damit...??? */

7 Pointer (Zeiger) Zeiger: speichern Adressen int Kapitel1 = 5; int Kapitel2 = 60; int Kapitel3 = 166; int Nachtrag = 233; int *Verzeichnis;

8 Pointer (Zeiger) Verzeichnis =&Kapitel1;

9 Pointer (Zeiger) int x = 5; int *y; y =&x; *y =10;

10 Pointer (Zeiger) Was wird hier ausgegeben?

11 Funktionen Aufruf einer Funktion calling function called function Hauptprogramm Hauptprogramm: Funktion x = add(10,5); Funktion add(int c, int d) { b = c + d; return b; Inline Funktionen (Optimierung): Compiler fügt die komplette Funktion direkt an die Stelle des Aufrufs. -> Sprung und Rücksprung fällt weg -> Ausführungsgeschwindigkeit wird erhöht

12 Funktionen Aufruf einer Funktion calling function called function Hauptprogramm: x = add(10,5); Funktion add(int c, int d) { b = c + d; return b;

13 Funktionen Text: Maschinencode des Programms Daten: statische und globale Variablen Stack: Funktionsaufrufe und lokale Variablen Heap: dynamisch reservierter Speicher

14 Funktionen [Spezifizierer] Rückgabetyp Funktionsname(Parameter) { /* Anweisungsblock mit Anweisungen */ int main(void) { /* mach was */ return 0; gcc o myapp main.c

15 Funktionen Funktionsdeklaration: - Funktion muss vor Aufruf deklariert werden. - Wichtig für den Compiler #include <stdio.h> void hilfe(void); int main(void) { hilfe(); return 0; void hilfe(void) { printf("ich bin die Hilfsfunktion\n");

16 Funktionen - Header Dateien Deklaration von Funktionen /*myheader.h*/ #ifndef MYHEADER_H #define MYHEADER_H #define PI (3.1416) extern int meinevariable; int meinefunktion1(int); int meinefunktion2(char); #endif /* MYHEADER_H */ /* myprog.c */ #include "myheader.h" int meinevariable = 0; int meinefunktion1 (int i) { return (i+1); int meinefunktion2 (char c) { if (c == 'A') return 1; return 0;

17 Funktionen Lokale und Globale Variablen: #include <stdio.h> int i=333; /* globale Variable i */ void aendern(void) { i = 111; /* Ändert die globale Variable. */ printf("in der Funktion aendern: %d\n",i); /* 111 */ int main(void) { int i = 444; printf("%d\n",i); /* 444 */ aendern(); printf("%d\n",i); /* 444 */ return 0;

18 Funktionen Lokale und Globale Variablen: Geltungsbereiche Block: (lokal) Innerhalb des Anweisungsblocks Funktion: (lokal) Innerhalb der Funktion Datei: (global) Innerhalb der Deklaration in der Datei

19 Funktionen Schlüsselwörter für Variablen Speicherklassen statische Lebensdauer Variable wird zu Programmbeginn einmal deklariert und initialisiert und existiert während der gesamten Programmausführung. automatische Lebensdauer Variable wird beim Eintritt in den Anweisungsblock, in dem sie definiert ist, neu erzeugt und beim Verlassen des Anweisungsblocks wieder gelöscht. auto auto int zahl = 5; extern Variable befindet sich in anderer Datei register um eine Variable im Prozessorregister zu halten. static statische Variable -> verliert nicht ihren Wert bei Beendigung des Bezugsrahmens. -> Wird im Datensegment gespeichert (nicht im Stacksegment)

20 Funktionen Schlüsselwörter für Funktionen Speicherklassen extern nicht unbedingt notwendig -> automatisch gesetzt falls nichts angegeben ist. static gegenteil von extern -> Funktion kann nur innerhalb der Datei genutzt werden, in der sie deklariert ist. volatile (keine Speicherklasse -> Typ-Qualifizierer) vergleich zu volatile bei Variablen Hinweis an den Compiler: Funktion muss immer neu aus dem Hauptspeicher gelesen werden -> keine Optimierung anwenden.

21 Funktionen Schlüsselwörter für Funktionen Speicherklassen volatile (keine Speicherklasse -> Typ-Qualifizierer) vergleich zu volatile bei Variablen Hinweis an den Compiler: Funktion/Variable muss immer neu aus dem Hauptspeicher gelesen werden -> keine Optimierung. static int foo; void bar(void) { foo = 0; while (foo!= 255) ; hier unerwünschte Optimierung durch Compiler void bar_optimized(void) { foo = 0; while (true) ; static volatile int foo; void bar (void) { foo = 0; while (foo!= 255) ;

22 Funktionen Funktionsaufruf #include <stdio.h> void mixed(int x, char y, float z) { printf("stückzahl : %d ",x); printf("klasse : %c ",y); printf("preis : %.2f Euro\n",z); int main(void) { mixed(6, 'A', 5.5f); mixed(9, 'B', 4.3f); return 0.

23 Funktionen Hauptfunktion main()

24 Funktionen Getrenntes Kompillieren von Quelldateien /*main.c*/ #include <stdio.h> #include <stdlib.h> extern void modul1(void); extern void modul2(void); int main(void) { modul1(); modul2(); return EXIT_SUCCESS; /*modul1.c*/ void modul1(void) { printf("ich bin das Modul 1\n"); /*modul2.c*/ void modul2(void) { printf("ich bin Modul 2\n"); gcc -c main.c gcc -c modul1.c gcc -c modul2.c gcc -o myapp main.o modul1.o modul2.o

25 Funktionen Getrenntes Kompillieren von Quelldateien gcc -c main.c gcc -c modul1.c gcc -c modul2.c gcc -o myapp \ main.o modul1.o modul2.o

26 Funktionen -> Makefile gcc -c main.c gcc -c modul1.c gcc -c modul2.c gcc -o myapp main.o modul1.o modul2.o prog: main.o modul1.o modul2.o gcc -o myapp main.o modul1.o modul2.o main.o: main.c gcc -c main.c modul1.o: modul1.c gcc -c modul1.c modul2.o: modul2.c gcc -c modul2.c

27 Makefile # ls -al total 24 drwxr-xr-x :41. drwxr-xr-x :35.. -rw-r--r :18 main.c -rw-r--r :17 makefile -rw-r--r :19 modul1.c -rw-r--r :19 modul2.c # make gcc -c main.c gcc -c modul1.c gcc -c modul2.c gcc -o prog main.o modul1.o modul2.o # ls -al total 44 drwxr-xr-x :41. drwxr-xr-x :35.. -rw-r--r :18 main.c -rw-r--r :41 main.o -rw-r--r :17 makefile -rw-r--r :19 modul1.c -rw-r--r :41 modul1.o -rw-r--r :19 modul2.c -rw-r--r :41 modul2.o -rwxr-xr-x :41 myapp #./myapp # make gcc -c main.c gcc -c modul1.c gcc -c modul2.c gcc -o myapp main.o modul1.o modul2.o

28 Makefile (Variablen setzen) prog: main.o modul1.o modul2.o gcc -o myapp main.o modul1.o modul2.o main.o: main.c gcc -c main.c modul1.o: modul1.c gcc -c modul1.c modul2.o: modul2.c gcc -c modul2.c CC = gcc OBJ = main.o modul1.o modul2.o prog: $(OBJ) $(CC) -o myapp $(OBJ) main.o: main.c $(CC) -c main.c modul1.o: modul1.c $(CC) -c modul1.c modul2.o: modul2.c $(CC) -c modul2.c

29 Makefile (Wildcards) prog: main.o modul1.o modul2.o gcc -o myapp main.o modul1.o modul2.o main.o: main.c gcc -c main.c modul1.o: modul1.c gcc -c modul1.c modul2.o: modul2.c gcc -c modul2.c CC = gcc OBJ = main.o modul1.o modul2.o CC = gcc OBJ = main.o modul1.o modul2.o prog: $(OBJ) $(CC) -o myapp $(OBJ) main.o: main.c $(CC) -c main.c modul1.o: modul1.c $(CC) -c modul1.c modul2.o: modul2.c $(CC) -c modul2.c prog: $(OBJ) $(CC) -o myapp $(OBJ) %.o: %.c $(CC) -c %.c

30 Makefile (Makros) prog: main.o modul1.o modul2.o gcc -o myapp main.o modul1.o modul2.o main.o: main.c gcc -c main.c modul1.o: modul1.c gcc -c modul1.c modul2.o: modul2.c gcc -c modul2.c CC = gcc OBJ = main.o modul1.o modul2.o prog: $(OBJ) $(CC) -o myapp $(OBJ) %.o: %.c $(CC) -c %.c CC = gcc OBJ = main.o modul1.o modul2.o prog: $(OBJ) $(CC) -o myapp $(OBJ) main.o: main.c $(CC) -c main.c modul1.o: modul1.c $(CC) -c modul1.c modul2.o: modul2.c $(CC) -c modul2.c CC = gcc OBJ = main.o modul1.o modul2.o prog: $(OBJ) $(CC) -o $@ $(OBJ) %.o: %.c $(CC) -c $<

31 Makefile #Dies ist ein Kommentar VERSION = 3.02 CC = /usr/bin/gcc CFLAGS = -Wall -g -D_REENTRANT -DVERSION=\"$(VERSION)\" LDFLAGS = -lm -lpthread `gtk-config --cflags` `gtk-config --libs` -lgthread OBJ = datei1.o datei2.o datei3.o datei4.o datei5.o prog: $(OBJ) $(CC) $(CFLAGS) -o prog $(OBJ) $(LDFLAGS) %.o: %.c $(CC) $(CFLAGS) -c $<

32 Dateizugriff File I/O #include <stdio.h> Datei Zugriff über Pointer FILE * myfile; Öffnen einer Datei mit fopen() myfile = fopen("filename.txt","r"); fopen wird als Parameter der Dateiname übergeben und mit welcher Operation auf die Datei zugegriffen werden soll: Operationen sind: "r" - Read Only (r+ open file for reading and writing) "w" - Rewrite over the existing file (w+ existing file will be deleted) "a" - append to the existing file (a+ if file does not exist it will be created) es gibt noch weitere Zugriffscodes

33 Dateizugriff File I/O Normalerweise sollte die Rückgabe auf Fehler überprüft werden if ((myfile = fopen(filename,"r")) == NULL) { printf("error opening %s\n",filename); Schreiben und Lesen mit fprint und fgets fprint(myfile,"this is line %d of your file",n); fgets(myfile,mystring); Formatiertes Lesen und Schreiben mit fprintf und fscanf int fprintf(file *f, const char * restrict format,...); int fscanf(file *f, const char * restrict format,...);

34 Dateizugriff /* fopen2.c */ #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { FILE *datei; if(argc < 2) { printf("verwendung : %s [datei_zum_oeffnen]\n", *argv); return EXIT_FAILURE; datei = fopen(argv[1], "r"); if(datei!= NULL) printf("datei erfolgreich geöffnet\n"); else { printf("fehler beim Öffnen der Datei"); return EXIT_FAILURE; return EXIT_SUCCESS;

35 Dateizugriff /* fopen2.c */ #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int x = 10; char y = hello world ; FILE *datei; datei = fopen( textfile.txt, w+ ); fprintf(datei, x: %d, y: %s, &x, &y); fclose(datei); Mit fflush() werden alle Inhalte von einem noch nicht geleerten Puffer eines Streams übertragen, die dem FILE-Zeiger datei zugeordnet sind (oder auch Standard-Streams). #include <stdio.h> int fflush(file *datei);

36 Debugging mit gdb GNU Debugger (gdb) UNIX-Programm zum diagnostizieren und Auffinden von Fehleren in Computersystemen / Programmen - Standard-Debugger von Linux-Systemen - Bietet Möglichkeiten zur Ablaufverfolgung wie Breakpoints, Ausgabe, Stacktrace, usw - Ermöglicht eingreifen in die Ausführung von Programmen. - Manipulieren von Variablen oder Funktionen unabhängig vom normalen Programmablauf Quelle:

37 Debugging mit gdb fact1.c int computefact(int n) { int accum=0; while(n>1) { accum *= n; n--; return accum;

38 Debugging mit gdb fact1.c 1: Programm kompillieren gcc -g -o fact1.x fact1.c 2: GDB starten gdb fact1.x 3: bestimmte Stellen im Code anschauen, z.b. Funktion computefact (gdb) list computefact 4: Breakpoint an einer bestimmten Stelle im Code setzen (gdb) break 44

39 Debugging mit gdb fact1.c 5: Programm starten (gdb) run 6: bestimmte Variablen anschauen (gdb) display accum 7: durch das Programm durchgehen und die Variable beobachten (gdb) step (gdb) 8: das Problem finden und beheben. (gdb) set accum = 1