Speicher und Adressraum

Transkript

1 Linearer Speicher (Adressraum) Technische Universität München Speicher und Adressraum Freie Speicherhalde (Heap) Freier Speicherstapel (Stack) Globale Variablen Bibliotheksfunktionen Laufzeitsystem Programmcode func2 Programmcode func1 Programmcode main

2 Speicher und Adressraum Die Halde (Heap) ist ein Speicherbereich, aus dem zur Laufzeit eines Programms zusammenhängende Speicherabschnitte angefordert und in beliebiger Reihenfolge wieder freigegeben werden können. Der Stapel (Stack) ist eine Speicherbereich, auf den Elemente nur `oben gespeichert und auch nur von dort wieder gelesen werden. Elemente werden übereinander gestapelt und in umgekehrter Reihenfolge vom Stapel genommen. (siehe später) Dies wird auch Last In First Out Prinzip (LIFO) genannt.

3 Speicher und Adressraum Verwendung der Halde int[][] a; a = new int[100][]; // Feld von 100 Verweisen for (int i = 0; i < 100; i++) // 100 int-felder mit Längen // von 1 bis 100 a[i] = new int[i+1]; Jedes dynamisch allokierte Feld wird auf der Halde angelegt Egal ob die Allokation im Hauptprogramm oder in einer Funktion stattfindet Für den Programmierer erst einmal nicht sichtbar

4 Speicher und Adressraum Verwendung des Stacks Funktionsaufrufe public static void set(int x) { x = 4; return; public static void main(string[] args) { int x = 2; set(x); write(x);

5 Linearer Speicher (Adressraum) Technische Universität München Speicher und Adressraum Frame von set: - Lokale Variablen - Rücksprungaddresse - etc. Freie Speicherhalde (Heap) Freier Speicherstapel (Stack) Globale Variablen Bibliotheksfunktionen Laufzeitsystem Programmcode func2 Programmcode sqr Programmcode main Frame von main: - Lokale Variablen - etc. Situation: main hat set aufgerufen

6 Speicher und Adressraum Verwendung des Stacks Funktionsaufrufe Beim Aufruf von main und den Funktionen/Prozeduren werden die jeweils lokalen Variablen (und evtl. die Rücksprungadresse) als sog. Frames auf den Stack gespeichert Während der Programmausführung ist jeweils nur der oberste Frame `sichtbar, und die als global definierten Variablen Bei der Beendigung einer Funktion/Prozedur (Rücksprung in das Hauptprogramm) wird der zur Funktion/Prozedur gehörende Stack gelöscht

7 Speicher und Adressraum Parameterübergabe an Funktionen in Java public static void set(int x) { x = 4; return; Stack public static void main(string[] args) { int x = 2; set(x); write(x); main()

8 Speicher und Adressraum Parameterübergabe an Funktionen in Java public static void set(int x) { x = 4; return; Stack public static void main(string[] args) { int x = 2; set(x); write(x); x = 2 main()

9 Speicher und Adressraum Parameterübergabe an Funktionen in Java public static void set(int x) { x = 4; return; Stack public static void main(string[] args) { int x = 2; set(x); write(x); Kopieren des Wertes von x nach lokales x in set x = 2; set() x = 2 main()

10 Speicher und Adressraum Parameterübergabe an Funktionen in Java public static void set(int x) { x = 4; return; Stack public static void main(string[] args) { int x = 2; set(x); write(x); x = 4; set() x = 2 main()

11 Speicher und Adressraum Parameterübergabe an Funktionen in Java public static void set(int x) { x = 4; return; Stack public static void main(string[] args) { int x = 2; set(x); write(x); x = 2 main()

12 Speicher und Adressraum Parameterübergabe an Funktionen in Java public static void set(int x) { x = 4; return; Stack public static void main(string[] args) { int x = 2; set(x); write(x); x = 2 main()

13 Speicher und Adressraum Parameterübergabe an Funktionen in Java public static void set(int x) { x = 4; return; Stack public static void main(string[] args) { int x = 2; set(x); write(x); Diese Art der Parameterübergabe nennt man Call-by-Value x = 2 main()

14 Speicher und Adressraum Parameterübergabe mittels Call-by-Reference void set(int &x) { x = 4; return; Stack void main(string[] args) { int x = 2; set(x); write(x); Die Funktion erhält die Adresse (&) von x und nicht dessen Wert main()

15 Speicher und Adressraum Parameterübergabe mittels Call-by-Reference void set(int &x) { x = 4; return; Stack void main(string[] args) { int x = 2; set(x); write(x); Die Funktion erhält die Adresse (&) von x und nicht dessen Wert x = 2 main()

16 Speicher und Adressraum Parameterübergabe mittels Call-by-Reference void set(int &x) { x = 4; return; Stack void main(string[] args) { int x = 2; set(x); write(x); Kopieren der Adresse von x nach lokales x in set (x = 0xA0000) sqr() x = 2 main()

17 Speicher und Adressraum Parameterübergabe mittels Call-by-Reference void set(int &x) { x = 4; return; Stack void main(string[] args) { int x = 2; set(x); write(x); (x = 0xA0000) sqr() x = 4 main()

18 Speicher und Adressraum Parameterübergabe mittels Call-by-Reference void set(int &x) { x = 4; return; Stack void main(string[] args) { int x = 2; set(x); write(x); x = 4 main()

19 Speicher und Adressraum Parameterübergabe mittels Call-by-Reference void set(int &x) { x = 4; return; Stack void main(string[] args) { int x = 2; set(x); write(x); x = 4 main()

20 Speicher und Adressraum Java kennt keinen Adress-Operator & Für primitive Datentypen wird automatisch ein Wertparameter verwendet, der beim Aufruf einer Funktion kopiert wird Call-by-Value Für Objekte (siehe später) wird die Objektreferenz als Wertparameter durch Kopie übergeben Call-by-Reference D.h., dass der Wert des Objektes verändert werden kann

21 Rekursive Funktionen Verwendung des Stacks Rekursion am Beispiel der Fakultätsberechnung public static int fak(int n) { if (n > 0) else return n * fak(n-1); return 1; Definition einer Funktion, die sich selbst aufruft, um den Funktionswert zu berechnen.

22 Fakultätsberechnung 6 fak(3) 3 * fak(2) 2 fak(2) 2 * fak(1) 1 fak(1) 1 * fak(0) public static int fak(int n) { if (n > 0) return n * fak(n-1); else return 1; fak(0) 1 1

23 Rekursive Funktionen Aufbau des Frame-Stacks public static int fak(int n) { if (n > 0) return n * fak(n-1); else return 1; Stack public static void main(string[] args) { int x; x = fak(3); write(x); main(): x = fak(3)

24 Rekursive Funktionen Aufbau des Frame-Stacks public static int fak(int n) { if (n > 0) return n * fak(n-1); else return 1; Stack public static void main(string[] args) { int x; x = fak(3); write(x); n = 3 return n * fak(2) main(): z = fak(3)

25 Rekursive Funktionen Aufbau des Frame-Stacks public static int fak(int n) { if (n > 0) return n * fak(n-1); else return 1; public static void main(string[] args) { int x; x = fak(3); write(x); Stack n = 2 return n * fak(1) n = 3 return n * fak(2) main(): x = fak(3)

26 Rekursive Funktionen Aufbau des Frame-Stacks public static int fak(int n) { if (n > 0) return n * fak(n-1); else return 1; public static void main(string[] args) { int x; x = fak(3); write(x); Stack n = 1 return 1 n = 2 return n * fak(1) n = 3 return n * fak(2) main(): x = fak(3)

27 Rekursive Funktionen Abbau des Frame-Stacks public static int fak(int n) { if (n > 0) return n * fak(n-1); else return 1; public static void main(string[] args) { int x; x = fak(3); write(x); Stack n = 1 return 1 n = 2 return n * fak(1) n = 3 return n * fak(2) main(): x = fak(3) 1

28 Rekursive Funktionen Abbau des Frame-Stacks public static int fak(int n) { if (n > 0) return n * fak(n-1); else return 1; public static void main(string[] args) { int x; x = fak(3); write(x); Stack n = 2 return n * fak(1) n = 3 return n * fak(2) main(): x = fak(3) 2

29 Rekursive Funktionen Abbau des Frame-Stacks public static int fak(int n) { if (n > 0) return n * fak(n-1); else return 1; Stack public static void main(string[] args) { int x; x = fak(3); write(x); n = 3 return n * fak(2) 6 main(): x = fak(3)

30 Rekursive Funktionen Abbau des Frame-Stacks public static int fak(int n) { if (n > 0) return n * fak(n-1); else return 1; Stack public static void main(string[] args) { int x; x = fak(3); write(x); main(): x = 6

31 Rekursion: die Türme von Hanoi Problem: setze alle Scheiben vom Stapel 1 auf den Stapel 2. Es darf nur eine Scheibe pro Zug bewegt werden. Es darf niemals eine größere Scheibe auf einer kleineren sitzen. Stapel #1 Stapel #2 Stapel #3

32 Rekursion: die Türme von Hanoi Rekursionsgleichung für die Türme von Hanoi Sei H n = Anzahl Züge für einen Stapel mit n Scheiben Dann sieht die Zug-Strategie wie folgt aus: Ziehe die obersten n 1 Scheiben auf den Ausweichstapel. (H n 1 Züge) Ziehe die unterste Scheibe. (1 Zug) Ziehe die obersten n 1 Scheiben auf die unterste Scheibe. (H n 1 Züge) Somit ergibt sich: H n = 2H n Die Anzahl Züge wird durch eine Rekursionsgleichung beschrieben.

33 Türme von Hanoi Wie viele Züge muss man machen? H n = 2 H n = 2 (2 H n 2 + 1) + 1 = 2 2 H n = 2 2 (2 H n 3 + 1) = 2 3 H n = 2 n 1 H n = 2 n n (da H 1 = 1) = n 1 i=0 2 i = 2 n 1

34 Rekursion (linear) rekursive Fakultätsberechnung (ein rekursiver Aufruf ) public static int f(int n) { if (n > 0) return n * f(n-1); else return 1; f(4) = 4*f(3) f(3) = 3*f(2) f(2) = 2*f(1) f(3) = 3*2=6 f(2) = 2*1=2 f(4) = 4*6=24 f(1) = 1

35 Rekursion Beobachtung: In der rekursiven Berechnung der Fakultät wird nach der Rekursion noch eine Multiplikation mit dem Argument n berechnet Es müssen Zwischenergebnisse auf dem Stack gespeichert werden und Die Funktion kann am Ende der Rekursion nicht direkt terminieren Eine Rekursion heißt endrekursiv, wenn der Aufruf der Rekursion die letzte Aktion zur Berechnung der rekursiven Funktion ist Endrekursive Funktionen zeigen ein besseres Verhalten hinsichtlich des Speicherbedarfs Wie kann man eine nicht endrekursive Funktion endrekursiv machen?

36 Rekursion Die Endrekursion kann z.b. durch Einführen einer Hilfsfunktion erreicht werden public static int h_f(int n, int fak) { if (n 1) return fak; else return h_f(n-1, fak*n); public static int f(int n) { return h_f(n, 1);

37 Rekursion Ablauf der Fakultätsberechnung mit endrekursiver Hilfsfunktion f(4) = h_f(4,1) = h_f(3,4*1) h_f(3,4) = h_f(2,4*3) h_f(2,12) = h_f(1,12*2) = 24

38 Rekursion Ein Beispiel für eine nichtlineare Rekursion (mehrfache rekursive Aufrufe in einer Funktion) Die Berechnung der Fibonacci Zahlen: 1, 1, 2, 3, 5, 8, 13, 21, 34,... mit der Rekursionsgleichung f n f n 1 + f n 2 mit f 1 f 2 1 Die Aufruffolge zeigt, dass viele Fibonacci Zahlen mehrfach berechnet werden und ~2 n Auswertungen benötigt werden f n f n 1 f n 2 f n 2 f n 3 f n 3 f n 4 f n 4 f n 3

39 Rekursion Hier nun die endrekursive Variante mit ~n Auswertungen public static int h_fib(int n, int fk1, int fk2) { if (n 1) return fk1+fk2; else return h_fib(n-1,fk2+fk1, fk1) public static int fib(int n) { return h_fib(n-1, 1,0);

40 Rekursion Allgemeine Struktur einer Endrekursion f n = g n falls T(n) f(r n ) sonst mit der Abbruchbedingung T(n)

41 Rekursion Iterative Berechnung einer endrekursiven Funktion f n = f r n = f r r n = f r 3 n = = f r k n = g(r k n ) hierbei ist k die kleinste Zahl für die P r k n = true Hieraus folgt die iterative Berechnung while(p(n)==false) n = r(n); return g(n);

42 Rekursion Iteration anstelle von Rekursion Die Endrekursion lässt sich immer durch eine n-fache for-schleife berechnen public static int fib(int n) { int f, fk1 = 1, fk2 = 0; while(--n) { f = fk1 + fk2; fk2 = fk1; fk1 = f; return fk1;

43 Rekursion Allgemeine Struktur einer linearen Rekursion f n = mit der Abbruchbedingung T(n) g n falls T(n) n, f r(n) sonst Expansion der rekursiven Definition ergibt f n = n, f r n = n, r n, f r 2 n = = (n, r n, r 2 n,, r k 1 n, g r k n Achtung: die Sequenz n, r n, r 2 n wird in umgekehrter Reihenfolge benötigt. Wie realisiert man das?

44 Rekursion Weitere Beispiele für rekursive Strukturen - Fraktale Sierpinski- Dreieck Koch- Kurve

45 Rekursion Rekursion in der Natur: die Mandelbrot Menge Rekursive Auswertung der Rekursionsgleichung für initiale Punkte c in der komplexen Zahlenebene (z i = 0) z i+1 = z i 2 + c (Färbung der Punkte zeigt Stärke des Wachstums von z i )