Übungspaket 29 Dynamische Speicherverwaltung: malloc() und free()

Transkript

1 Übungspaket 29 Dynamische Speicherverwaltung: malloc() und free() Übungsziele: Skript: In diesem Übungspaket üben wir das dynamische Alloziieren 1. und Freigeben von Speicherbereichen 2. von Zeichenketten 3. beliebiger Arrays Kapitel: 69 Semester: Wintersemester 2017/18 Betreuer: Kevin, Theo, Thomas und Ralf Synopsis: Endlich wird es spannend :-) Einige von euch haben schon bemerkt, dass man bei den Arrays immer schon vorher wissen muss, wie viele Elemente man benötigt. Manchmal weiß man das aber nicht. In diesem Übungspaket üben wir, Speicher dynamisch zu alloziieren und auch wieder freizugeben. Wenn man sich daran erst einmal gewöhnt hat, ist es ganz praktisch. Aber das ist ja immer so...

2 Teil I: Stoffwiederholung Aufgabe 1: Motivation Auf den ersten Blick mag die dynamische Speicherverwaltung überflüssig wie ein Kropf zu sein, denn wir können ja alle Variablen, insbesondere Arrays, schon zur Übersetzungszeit festlegen. Erste Antwort: sie ist natürlich nicht überflüssig, würden wir sie sonst behandeln ;-)? Überlege und beschreibe in eigenen Worten, in welchen Fällen eine dynamische Speicherverwaltung notwendig bzw. nützlich ist. Die Antwort steht eigentlich schon in der Fragestellung: denn wir können ja alle Variablen insbesondere Arrays schon zur Übersetzungszeit festlegen. Das können wir in vielen Fällen nämlich genau nicht. Beispielsweise wissen wir nicht, wie viele Zahlen wir im Rahmen des Programms verarbeiten müssen. Oder wir wissen nicht, wie lang die zu verarbeitenden Zeichenketten sind. Das heißt eben auch, dass wir die Größe eines Arrays eben nicht immer von vornherein wissen und unsere Arrays beim Schreiben des Programms definieren können. Entsprechend müssen wir uns damit abfinden, dass die dynamische Speicherverwaltung insbesondere bei Arrays auch bei uns zur Anwendung kommt. Aufgabe 2: Fragen zu den Grundlagen Für die dynamische Speicherverwaltung verwenden wir im Wesentlichen zwei Funktionen. Wie heißen diese Funktionen und welche Signaturen haben sie? Dynamische Speicherallokation: void * malloc( int size ) Dynamische Speicherfreigabe: void free( void * ptr ) Welche Datei muss man für diese Funktionen einbinden? In welchem Segment liegt der neue Speicher? Wie/in welcher Form wird der Speicher zurückgegeben? Welchen Wert hat der Zeiger im Fehlerfalle? #include <stdlib.h> Auf dem Heap Als Zeiger auf das erste Byte Es ist ein Null-Zeiger Aufgabe 3: Ein einfaches Beispiel Im Folgenden betrachten wir eine kleine, nutzlose Beispielanwendung. Diese Anwendung fragt den Benutzer nach der Zahl der Parameter, die er benötigt. Anschließend alloziiert das Programm ein entsprechendes Array und, sofern dies erfolgreich war, initialisiert es die Elemente mit den Werten 0, 2, 4,... Einführung in die Praktische Informatik, Wintersemester 2017/

3 1 # include <stdio.h> 2 # include < stdlib.h> 3 4 int main ( int argc, char ** argv ) 5 { 6 int i, size, *p; 7 printf ( " wie viele int s benoetigst du? " ); 8 scanf ( "%d", & size ); 9 if ( size > 0 ) 10 { 11 p = malloc ( size * sizeof ( int ) ); 12 for ( i = 0; i < size ; i ++ ) 13 p[ i ] = i * 2; 14 printf ( " Kontrollausgabe :" ); 15 for ( i = 0; i < size ; i ++ ) 16 printf ( " %d", p[ i ] ); 17 printf ( "\n" ); 18 } 19 else printf ( " sorry, da kann ich nicht helfen \ n" ); 20 } Wir wollen nun von euch, dass ihr ein Speicherbildchen malt, in denen die Variablen i, size und p enthalten sind. Ebenso wollen wir den neu alloziierten Speicherbereich sowie die in den Zeilen 12 und 13 generierten Initialwerte sehen. Für das Beispiel nehmen wir an, dass der Nutzer die Zahl 3 eingegeben hat. Mit anderen Worten: Wie sieht der Arbeitsspeicher unmittelbar vor Ausführung der Programmzeile 14 aus? Segment: Stack Adresse Variable Wert 0xFE28 int * p : 0xF040 0xFE24 int size : 3 0xFE20 int i : 3 Segment: Heap Adresse Variable Wert 0xF048 int [ 2 ] : 4 0xF044 int [ 1 ] : 2 0xF040 int [ 0 ] : Wintersemester 2017/18, Einführung in die Praktische Informatik

4 Teil II: Quiz Aufgabe 1: Speicherallokation In der folgenden Tabelle stehen in den drei Spalten der Reihe nach das auszuführende Kommando, die angelegte Datenstruktur und die Zahl der Bytes, die diese im Arbeitsspeicher belegt. Dabei gehen wir davon aus, dass ein char 1 Byte, ein int sowie ein Zeiger jeweils 4 Bytes und ein double 8 Bytes im Arbeitsspeicher belegt. Vervollständige die fehlenden Spalten. Im Sinne eines etwas erhöhten Anspruchs haben wir noch die folgende Struktur: 1 struct bla { int bla_ bla ; double blub_ blub ; }; malloc()-aufruf Datenstruktur Größe malloc(3 * sizeof( int )) Array mit 3 ints 12 malloc(5 * sizeof( double )) Array mit 5 double 40 malloc( 12 ) Vermutlich ein Array mit 12 char 12 malloc(2 * sizeof(struct bla)) Array mit 2 struct bla Elementen 24 malloc(2 * sizeof(struct bla *)) Array mit 2 Zeigern auf auf Elemente 8 vom Typ struct bla malloc(5 * sizeof(char *)) Array mit 5 char-zeigern 20 malloc(13) ein char-array 13 malloc(6 * sizeof(double **)) ein Array mit 6 Zeigern auf double- Zeiger 24 Aufgabe 2: Speicherfreigabe Erkläre mit eigenen Worten, was folgende Funktion macht: 1 void tst_and_free ( void * p ) 2 { 3 if ( p!= 0 ) 4 free ( p ); 5 } Diese Funktion gibt Speicher wieder frei, da sie offensichtlich die Funktion free() aufruft. Allerding testet sie vorab, ob es sich um einen regulären Zeigerwert handelt. Mit anderen Worten: Diese Funktion vermeidet es, einen Null-Zeiger versehentlich freizugeben, da dies unter Umständen innerhalb von free() zu einem Programmabsturz führen könnte. Einführung in die Praktische Informatik, Wintersemester 2017/

5 Teil III: Fehlersuche Aufgabe 1: Fehler bei malloc() und free() Der berühmt-berüchtigte Manager Dr. M. al Loc fand die Idee mit den dynamischen Datenstrukturen so spannend, dass er es gleich einmal ausprobierte. Er wollte eine Funktion haben, die ihm ein Array mit size doubles erzeugt, wobei die einzelnen Elemente mit den Werten 0.0, 1.0,... initialisiert werden sollen. Am Ende soll der Speicher wieder freigegeben werden. Finde und korrigiere die Fehler: 1 # include < stdio. h > // for printf () und scanf () 2 # include < stdlib. h > // for malloc () and free () 3 4 double * mk_darray ( int n ) 5 { 6 int i; double d_a ; // compact due to space 7 if (( d_a = malloc ( n ))!= 0 ) 8 for ( i = 0; i < n; i ++ ) 9 d_a [ i ] = i; 10 return d_a ; 11 } int main ( int argc, char ** argv ) 14 { 15 int i, size ; double * dp; // compact due to space 16 printf (" wie viele parameter? "); scanf ("%d", & size ); 17 dp = mk_darray ( size ); 18 printf ( " hier das ergebnis :" ); 19 for ( i = 0; i < size ; i ++ ) 20 printf ( " %5.2 f", dp[ i ] ); 21 printf ( "\n" ); 22 free ( dp ); // free the memory 23 free ( dp ); // just to be absolutely sure 24 return 0; 25 } Zeile Fehler Erläuterung Korrektur 6 * fehlt Die Variable d a muss natürlich als Zeiger definiert werden, da malloc() einen Zeiger auf einen neuen Speicherbereich zurückgibt. *d a 29-4 Wintersemester 2017/18, Einführung in die Praktische Informatik

6 Zeile Fehler Erläuterung Korrektur 7 sizeof() fehlt Ein ganz typischer Fehler: In diesem Falle würde malloc() nur n Bytes bereitstellen. Wir benötigen aber n * sizeof(double) Bytes, was wir beim Aufruf von malloc() unbedingt berücksichtigen müssen. sizeof() ff. Test auf Null-Zeiger fehlt In Zeile 17 wird ein neuer Speicherplatz dynamisch alloziiert. Aber dies kann schief gehen, was durch einen Null-Zeiger angezeigt wird. Da man Null-Zeiger nicht dereferenzieren (auf die Inhalte zugreifen) darf, muss der nachfolgende Programmtext geklammert werden. if () /23 ein free() zu viel Programm mit Korrekturen: Einen zuvor alloziierten Speicherplatz darf man nur einmal freigeben. Das Ergebnis durch den zweiten Aufruf ist unbestimmt und kann hier oder später zu einem Programmabsturz führen. ein free() streichen 1 # include < stdio. h > // for printf () und scanf () 2 # include < stdlib. h > // for malloc () and free () 3 4 double * mk_darray ( int n ) 5 { 6 int i; double * d_a ; // compact due to space 7 if (( d_a = malloc ( n * sizeof ( double )))!= 0 ) 8 for ( i = 0; i < n; i ++ ) 9 d_a [ i ] = i; 10 return d_a ; 11 } int main ( int argc, char ** argv ) 14 { 15 int i, size ; double * dp; // compact due to space 16 printf (" wie viele parameter? "); scanf ("%d", & size ); 17 if ( dp = mk_darray ( size )) 18 { 19 printf ( " hier das ergebnis :" ); 20 for ( i = 0; i < size ; i ++ ) 21 printf ( " %5.2 f", dp[ i ] ); 22 printf ( "\n" ); 23 free ( dp ); 24 } 25 return 0; 26 } Einführung in die Praktische Informatik, Wintersemester 2017/

7 Teil IV: Anwendungen Aufgabe 1: Aneinanderhängen zweier Zeichenketten 1. Aufgabenstellung Entwickle eine Funktion, die als Eingabeparameter zwei Zeiger auf je eine Zeichenkette erhält, diese beiden Zeichenketten zu einer neuen Zeichenkette zusammenfügt und das Ergebnis als Zeiger auf diese zurückgibt. Beispiel: Aufruf: my strcat( "Prof.", "Weiss-Nicht" ) Ergebnis: "Prof. Weiss-Nicht" Diese Funktion kann wieder einfach mittels des argc/argv-mechanismus getestet werden. 2. Vorüberlegungen Was können wir aus der Aufgabenstellung direkt ablesen? 1. Wir müssen zwei Zeichenketten zusammenfügen, deren Längen wir zur Übersetzungszeit noch nicht wissen. 2. Daraus folgt, dass wir das Ergebnis nicht auf dem Stack ablegen können, sondern uns den benötigten Speicherplatz dynamisch vom Heap besorgen müssen. 3. Die neue Zeichenkette muss so lang sein, dass die beiden alten hinein passen, dann noch ein Leerzeichen und am Ende ein Null-Byte. 3. Pflichtenheft Aufgabe : Funktion zum Verknüpfen zweier Zeichenketten. Das Ergebnis wird auf dem Heap abgelegt. Parameter : Zwei Eingabeparameter p1 und p2 vom Typ char * Rückgabewert : Einen Zeiger auf eine neue Zeichenkette vom Typ char * 4. Testdaten Ähnlich wie in der Aufgabenstellung beschrieben. Bei Verwendung des argc/argv- Mechanismus nehmen wir argv[ 1 ] als ersten Namen und alle weiteren Parameter als zweiten Namen. Beispiel: Eingabe:./my-strcat Dr. Peter Maria Ausgabe: Dr. Peter Dr. Maria 29-6 Wintersemester 2017/18, Einführung in die Praktische Informatik

8 5. Implementierung Da wir den argc/argv-mechanismus schon eingehend geübt haben, können wir uns ganz auf die neu zu entwickelnde Funktion konzentrieren. Die wesentlichen Punkte standen schon in den Vorüberlegungen. Wir erhalten zwei Zeichenketten. Die Länge der neuen Zeichenkette muss die Summe der beiden eingehenden Zeichenketten sein, plus eins für das Leerzeichen und eins für das abschließende Null-Byte. Das lässt sich wie folgt ausdrücken: Funktion zum Aneinanderhängen von Zeichenketten Parameter: Pointer to Char: p1, p2 Variablen: Integer: len1, len2 Pointer to char: res // zwei laengenwerte // der rueckgabewert setze len1 = strlen( p1 ) setze len2 = strlen( p2 ) setze res = malloc(len1 + len2 + 2) wenn res 0 dann kopiere p1 an die Stelle res[ 0 ] kopiere ein Leerzeichen an die Stelle res[ len1 ] kopiere p2 an die Stelle res[len1 + 1] kopiere ein Null-Byte an die Stelle res[len len2] return res 6. Kodierung Unsere Funktion my strcat(): 1 # include <stdio.h> // for I/O 2 # include < string. h > // for strlen () und strcpy () 3 # include < stdlib. h > // for malloc () 4 5 char * my_strcat ( char * p1, char * p2 ) 6 { 7 char * res ; 8 int len1 = strlen ( p1 ), len2 = strlen ( p2 ); 9 if ( res = malloc ( len1 + len2 + 2 )) 10 { 11 strcpy ( res, p1 ); 12 res [ len1 ] = ; 13 strcpy ( res + len1 + 1, p2 ); 14 res [ len1 + len2 + 1] = \0 ; 15 } 16 return res ; 17 } Einführung in die Praktische Informatik, Wintersemester 2017/

9 Das ist unser Hauptprogramm zum Testen: 18 int main ( int argc, char ** argv ) 19 { 20 int i; 21 char * combi ; 22 for ( i = 2; i < argc ; i ++ ) 23 if ( combi = my_strcat ( argv [ 1 ], argv [ i ] )) 24 { 25 printf ( " my_strcat : %s \n", combi ); 26 free ( combi ); // otherwise : memory leak! 27 } 28 } 29-8 Wintersemester 2017/18, Einführung in die Praktische Informatik

10 Aufgabe 2: Verallgemeinertes strcat() 1. Aufgabenstellung In dieser Aufgabe soll die Funktion my strcat() der vorherigen Aufgabe erweitert werden. Statt nur zwei Zeichenketten zusammenzufügen, soll die Funktion diesmal in der Lage sein, beliebig viele Zeichenketten zu verarbeiten. Die einzelnen Zeichenketten sollen wieder mittels eines Leerzeichens voneinander getrennt werden. Natürlich muss die gesamte Zeichenkette wieder mit einem Null-Byte abgeschlossen werden. Innerhalb dieser Übungsaufgabe nennen wir diese Funktion my nstrcat() Beispiel: Bei Übergabe der drei Parameter "Frau", "Peter" und "Otti" soll das Ergebnis "Frau Peter Otti" lauten. Zum Testen bedienen wir uns wieder des argc/argv-mechanismus. 2. Vorüberlegungen Auch hier ist es wieder sinnvoll, ein paar Vorüberlegungen anzustellen. Doch diesmal werden wir diese als Fragen formulieren, die ihr beantworten müsst. Erfordert die Aufgabenstellung eine dynamische Bearbeitung mittels malloc()? Falls ja, warum? Ja, unbedingt Anzahl und Längen der Zeichenketten sind unbekannt Falls nein, warum nicht? Die Aufgabe wäre in einem anderen Übungspaket ;-) Wie übergeben wir die Zeichenketten? Welchen Datentyp hat dieser Parameter? Benötigen wir noch einen zweiten Paramenter? Falls ja, welchen Typ hat dieser Parameter? Welchen Typ hat die Funktion? Wie lautet die vollständige Funktionsdeklaration? Wie bestimmen wir die Länge einer Zeichenkette? Wie lang ist die Ergebnis- Zeichenkette? In einem Array verpackt Array of Pointer to Char: char ** Ja int size char * char *my nstrcat( char **str arr, int size ) len = strlen( zeichenkette ) size 1 i=0 strlen( zeichenkette[ i ] ) Einführung in die Praktische Informatik, Wintersemester 2017/

11 3. Pflichtenheft Aufgabe : Funktion zum Verknüpfen von n Zeichenketten. Das Ergebnis wird auf dem Heap abgelegt. Parameter : Zwei Eingabeparameter: char **str arr und int size Rückgabewert : Einen Zeiger auf eine neue Zeichenkette vom Typ char * 4. Testdaten Wir bedienen uns wieder des argc/argv-mechanismus: Beispiel: Kommando:./my-strcat Dr. Peter Maria Ausgabe:./my-strcat Dr. Peter Maria als eine Zeichenkette 5. Implementierung Wir können uns gleich auf die Funktion my nstrcat() konzentrieren. Wir müssen der Reihe nach die folgenden Schritte durchführen: Erstens, Berechnung der Gesamtlänge der neuen Zeichenkette. Diese ist die Summe der Einzellängen plus die Anzahl der Zeichenketten (n 1 Leerzeichen als Trenner sowie ein Null-Byte am Ende). Zweitens, Allokation der neuen Zeichenkette. Und drittens, Hineinkopieren der einzelnen Zeichenketten mit jeweils einem anschließenden Leerzeichen. Das letzte Leerzeichen wird durch ein Null-Byte ersetzt. Bei jedem Kopiervorgang müssen wir in der neuen Zeichenkette um so viele Positionen weiterrücken, wie die zuletzt kopierte Zeichenkette lang war. Das lässt sich wie folgt ausdrücken: Funktion zum Aneinanderhängen von Zeichenketten Parameter: Array of Pointer to Char: str arr Integer: size Variablen: Integer: i, len, pos setze len = o für i = 0 bis size - 1 Schrittweite 1 wiederhole setze len = strlen( str arr[ i ] ) setze res = malloc( len + size ) wenn res 0 dann setze pos = 0 für i = 0 bis size - 1 Schrittweite 1 wiederhole kopiere str arr[ i ] an die Stelle res[ pos ] setze pos = pos + strlen( str arr[ i ] ) setze res[ pos ] = Leerzeichen setze pos = pos + 1 setze res[ pos ] = Null-Byte return res Wintersemester 2017/18, Einführung in die Praktische Informatik

12 6. Kodierung 1 # include <stdio.h> // for I/O 2 # include < string. h > // for strlen () und strcpy () 3 # include < stdlib. h > // for malloc () 4 5 char * my_nstrcat ( char ** str_arr, int size ) 6 { 7 char * res ; 8 int i, len, pos ; 9 for ( i = 0, len = size ; i < size ; i ++ ) 10 len += strlen ( str_arr [ i ] ); 11 if ( res = malloc ( len )) 12 { 13 for ( i = pos = 0; i < size ; i ++ ) 14 { 15 strcpy ( res + pos, str_ arr [ i ] ); 16 pos += strlen ( str_arr [ i ] ); 17 res [ pos ] = ; 18 pos ++; // advance to the next position 19 } 20 res [ pos - 1 ] = \0 ; // replace last blank 21 } 22 return res ; 23 } int main ( int argc, char ** argv ) 26 { 27 char * combi ; 28 if ( combi = my_nstrcat ( argv, argc )) 29 { 30 printf ( " my_nstrcat : %s \n", combi ); 31 free ( combi ); // just to get used to it 32 } 33 } Anmerkung: Wir hätten auch auf eine der beiden Variablen len oder pos verzichten können. Nur fanden wir es so verständlicher. Und die Einsparung einer int-variablen fällt bei den Zeichenketten nicht ins Gewicht. Einführung in die Praktische Informatik, Wintersemester 2017/