Zeiger und dynamischer Speicher

Transkript

1 Informatik für Elektrotechnik und Informationstechnik Benedict Reuschling Hochschule Darmstadt Fachbereich Informatik WS 2013/14 Zuletzt aktualisiert: , 07:49 Uhr Foliensatz basiert auf Materialien von Prof. Dr. Alois Schütte

2 Motivation Zeiger sind Variablen, die statt konkreten Werten die Adressen im Speicher von anderen Variablen enthalten. Wie andere Variablen auch, besitzen Sie einen Namen und es gibt bestimmte Operationen mit den dazugehörigen Operatoren. Zeiger ermöglichen viel der Funktionalität in C++, u.a. auch das dynamische allokieren von Hauptspeicher. Dadurch wird die Speicherverwaltung in die Hände des Programmierers gelegt. Zeiger besitzen daher einige Tücken: durch unsachgemässe Behandlung können Programmfehler entstehen, werden allokierte Ressourcen nicht wieder freigegeben, entstehen sog. memory leaks, der Code kann unleserlich und daher schlecht wartbar werden. Durch die richtige Anwendung entsteht effektiver, ressourcenschonender Code, der C++ sehr flexibel macht. 2 / 29

3 Zeiger Überblick 1 Zeiger Zeiger und Vektoren (Arrays) Rekursive dynamische Strukturen 2 Dynamischer Speicher Anlegen und Löschen mit new und delete Verkettete Listen 3 / 29

4 Zeiger Zeiger und Adressen Wie jede Variable auch, müssen Zeiger vor der Verwendung deklariert werden. Zeiger unterscheiden sich von normalen Variablen durch einen Stern (engl. Asterisk) * vor ihrem Variablennamen. Datentyp * Variablenname; Durch den Addressoperator & lässt sich die Speicheradresse einer Variablen ermitteln. 1 # include <iostream > 2 using namespace std; 3 4 int main () { 5 int x = 5; 6 int *px = &x; // px enthaelt die Adresse von Variable x 7 cout << "x: " << x << " an Adresse " << &x << endl ; 8 cout << "px: " << px << endl ; 9 return 0; 10 } Beispielausgabe: x: 5 an Adresse 0x7fff5fa2bb48 px: 0x7fff5fa2bb48 4 / 29

5 Zeiger Referenzieren und Dereferenzieren Da ein Zeiger die Addresse eines Objekts enthält, kann auf das Objekt auf zwei Arten zugegriffen werden: direkt über den Namen indirekt über den Zeiger. Um indirekt auf den Variablenwert zuzugreifen, wird der Operator * zum Dereferenzieren benutzt. C++ Code int *p; int *p; int x; p = &x; int x,y; int *p; x = 2; p = &x; y = *p; Erläuterung p ist eine Zeigervariable auf eine int-variable. Da keine Initialisierung vorgenommen wurde, ist der Inhalt unbestimmt. p wird die Adresse der Variablen x zugewiesen, man sagt: p zeigt auf x. p zeigt auf x. Durch y = *p (Dereferenzierung von p) wird derselbe Effekt erzielt, wie y = x. Bei der Dereferenzierung wird mit dem Wert auf den gezeigt wird gearbeitet, anstatt wie sonst mit der Adresse. 5 / 29

6 Zeiger Weitere Beispiele C++ Code int x = 2; int *p1, *p2; p1 = &x; p2 = p1; int* ip, x; int * ip, x; int *ip, x; Erläuterung Der Variablen p2 wird der Wert der Variablen p1 zugewiesen; dadurch zeigt p2 auf dasselbe Objekt wie p1. Alle diese Deklarationen sind äquivalent, da der * sich nur auf den ihm nachfolgenden Namen bezieht. Wird eine Zeigervariable deklariert, so ist sie nicht automatisch initialisiert; sie zeigt irgendwo hin. Will man sie auf einen definierten Wert setzen, aber noch nicht auf eine bestimmte Variable, so kann der spezielle Zeigerwert NULL verwendet werden. 6 / 29

7 Zeiger Rang der Zeigeroperatoren In Ausdrücken wie y = *p + 1; haben die Operatoren * und & höheren Rang als arithmetische Operatoren. Das bedeutet, dass zuerst oben das Objekt ermittelt (dereferenziert) und dann der Wert um 1 erhöht wird. Achtung: y = *(p+1) ist möglich, hat aber eine andere Bedeutung. C++ Code int *p; int x=3; p = &x; x = *p + 1; int *p; int x=2; p = &x; *p = -5; int *p; int x=2; p = &x; *p += 1; Erläuterung Zuerst wird dereferenziert, d.h. der Wert von der Speicherstelle, auf die p zeigt ermittelt (x==3), dann der Wert erhöht (4) und der Variablen x zugewiesen. Zuerst die Speicherstelle, auf die p zeigt ermittelt (x), dann der Wert dieser Speicherstelle auf -5 gesetzt. Inkrementiert x. Durch (*p)++; würde der gleiche Effekt erzielt. Die Klammern sind wegen des Operatorranges erforderlich. 7 / 29

8 Zeiger Konstante Zeiger Zeiger sind auch als Konstante deklarierbar. Sie zeigen dann stets auf dasselbe Objekt. Auch können Zeiger auf Konstanten deklariert werden. Solche Deklarationen sind von rechts nach links zu lesen. C++ Code const int X=42; const int C=18; const int *P=&C; P=&X; int x=42; const int C=18; int *const P=&x; *P = -1; const int C=18; const int *const P=&C; Erläuterung P ist Zeiger auf eine int-konstante. Der Zeiger kann danach auch auf anderes zeigen. P ist konstanter Zeiger auf ein int-objekt. Der Zeiger kann danach nicht verändert werden, aber das Objekt auf das er zeigt. P ist konstanter Zeiger auf eine int- Konstante. Der Zeiger kann danach nicht verändert werden, das Objekt auf das er zeigt ebenfalls nicht. 8 / 29

9 Zeiger Zeiger und Vektoren (Arrays) Überblick 1 Zeiger Zeiger und Vektoren (Arrays) Rekursive dynamische Strukturen 2 Dynamischer Speicher Anlegen und Löschen mit new und delete Verkettete Listen 9 / 29

10 Zeiger Zeiger und Vektoren (Arrays) Zeiger und Vektoren Zeiger und Arrays (häufig auch Vektoren genant) sind stark verwand: Jede Operation mit Vektor-Indezes kann auch mit Zeigern formuliert werden! Die mit Zeiger formulierte Version ist i.a. effizienter, jedoch manchmal schwerer zu lesen. Durch int a[10] wird ein Vektor mit Namen a definiert, der 10 Integer-Komponenten a[0], a[1], bis a[9] hat. Dann bezeichnet a[i] die Komponente, die i Positionen von der ersten Komponente entfernt ist. Wenn pa ein Zeiger auf ein int-objekt ist, also int *pa dann kann durch pa = &a[0]; pa die Adresse der Komponente 0 zugewiesen werden. 10 / 29

11 Zeiger Zeiger und Vektoren (Arrays) Vektoren im Speicher int a[10]; int *pa = &a[0]; int a[10]; int *pa = &a[i]; Der C/C++-Compiler verwandelt einen Verweis auf einen Vektor stets in einen Zeiger-Wert auf den Anfang des Vektors. Das heisst der Name eines Vektors ist die Startadresse im Speicher. Daher gilt immer: *(pa+i) == a[i] 11 / 29

12 Zeiger Zeiger und Vektoren (Arrays) Zeiger und Vektoren - Konsequenzen Ausdruck ist äquivalent zu Erläuterung pa = &a[0]; pa = a; Der Name des Vektors ist Synonym für die Adresse der Komponente 0. &a[i] a+i; Adresse der Komponente i a[i] *(a+i) Inhalt der Komponente i pa[i] *(pa+i) pa ist Synonym für Vektoranfang Allgemein kann man sagen: Statt Vektorname und Indexausdruck kann man immer einen Zeiger und den Abstand zum Anfang angeben und umgekehrt. Diese Konvention ist unabhängig vom Typ des Vektors, da die Addition von 1 zu einem Zeiger definiert ist als das Inkrementieren in Abhängigkeit des Speicherplatzbedarfs des Objektes, auf den der Zeiger zeigt. 12 / 29

13 Zeiger Zeiger und Vektoren (Arrays) Unterschied Vektorname und Zeiger Ein Zeiger ist eine Variable, also sind die folgenden Anweisungen sinnvoll und möglich: Gültige Deklaration: 1 int a [10]; 2 int *pa; 3 pa = a; 4 pa ++; Ein Vektorname ist vom Wesen her eine Konstante und kann daher kein L-Wert sein. Somit sind die folgenden Anweisungen für int a[10]; int *pa; nicht möglich: Ungültige Deklaration: 1 a = pa; 2 a++; 3 pa = &a; 13 / 29

14 Zeiger Rekursive dynamische Strukturen Überblick 1 Zeiger Zeiger und Vektoren (Arrays) Rekursive dynamische Strukturen 2 Dynamischer Speicher Anlegen und Löschen mit new und delete Verkettete Listen 14 / 29

15 Zeiger Rekursive dynamische Strukturen Rekursive dynamische Strukturen Zeiger sind nicht nur auf einfache Objekte möglich. Ein Zeiger kann auch auf eine Struktur (struct) zeigen. Da ein Element der Struktur selbst wieder ein Zeiger sein kann, entsteht eine rekursive Datenstruktur. Wenn ein Zeiger auf eine Struktur zeigt, kann eine Komponente selektiert werden durch Verwendung des Selektions- und des Dereferenzierungsoperators: -> 15 / 29

16 Zeiger Rekursive dynamische Strukturen Beispiel zu rekursiven dynamischen Strukturen C++ Code struct tupel { int i; double d; } wert; wert.i = 18; wert.d = 1.5; struct tupel *ps; ps = &wert; (*ps).i = 42; cout << ps->i; Erläuterung Definition einer Variable wert, die eine Struktur von einem int und einem double ist. Zeiger auf Struktur tupel; ps zeigt auf Variable wert. Komponente i der Struktur selektieren, auf die ps zeigt und den Wert 42 zuweisen. Kurzschreibweise für (*ps).i ist: ps->i Ausgabe: 42 Hinweis: Auch hier ist der Rang der Operatoren wichtig: ++ps->i; Entspricht ++(p->i), also wird die Komponente i inkrementiert. (++ps)->i; Inkrementiert ps, zeigt also auf ein anderes Objekt und dann wird die Komponente i selektiert! 16 / 29

17 Dynamischer Speicher Überblick 1 Zeiger Zeiger und Vektoren (Arrays) Rekursive dynamische Strukturen 2 Dynamischer Speicher Anlegen und Löschen mit new und delete Verkettete Listen 17 / 29

18 Dynamischer Speicher Motivation Die bisher behandelten Datentypen waren statisch der Compiler konnte den Speicherplatzbedarf ermitteln. In vielen Anwendungen ist der erforderliche Platzbedarf aber erst zur Laufzeit des Programms bekannt; z.b. wenn der Platz von der Anzahl der Benutzereingaben abhängt. Eine Idee ist es, ein sehr großes Array von Datenobjekten zu deklarieren und dort die Werte zu speichern. Besser wäre es, man könnte Speicher zur Laufzeit bei Bedarf anfordern (allokieren). Ein Programm wird vom Betriebssystem (je nach Betriebssystem unterschiedlich) im Speicher etwa wie folgt abgelegt: 18 / 29

19 Dynamischer Speicher Anlegen und Löschen mit new und delete Überblick 1 Zeiger Zeiger und Vektoren (Arrays) Rekursive dynamische Strukturen 2 Dynamischer Speicher Anlegen und Löschen mit new und delete Verkettete Listen 19 / 29

20 Dynamischer Speicher Anlegen und Löschen mit new und delete Anlegen und Löschen mit new und delete Um ein neues Element im Heap ablegen zu können, verwendet man den Operator new. Der erforderliche Speicherplatz wird durch new in Abhängigkeit des Typs automatisch ermittelt. Um den so allokierten Speicherplatz wieder freizugeben, verwendet man den Operator delete. Wird der Speicher nicht mehr freigegeben, so entstehen memory leaks! Für jedes new sollte ein passendes delete vorhanden sein! C++ Code int *p; p = new int; *p = 12; delete p; Erläuterung Ein neues Element wird auf dem Heap angelegt, es hat keinen Namen. Der Zugriff erfolgt über den Zeiger p. Der Wert ist undefiniert. Die Grösse ist sizeof(int). Anschliessend wird wie gewohnt ein Wert (hier 12) zugewiesen. Danach wird mit delete der Speicher wieder freigegeben. 20 / 29

21 Dynamischer Speicher Anlegen und Löschen mit new und delete Dynamische Arrays mit new anlegen Über den new []-Operator lassen sich auch dynamisch Arrays erzeugen. 1 int *pa; 2 pa = new int [3]; 3 pa [1] = 23; Der Zugriff erfolgt wie bei Arrays über den Zeiger und den Index. 1 # include <iostream > 2 using namespace std; 3 4 int main () { 5 int i,n; 6 int *p; 7 cout << " Wieviele Zahlen wollen Sie eingeben? "; 8 cin >> i; 9 p= new int [i]; 10 for (n=0; n<i; n++) { 11 cout << " Bitte Zahl eingeben : "; 12 cin >> p[n]; 13 } 14 cout << " Sie haben folgende Zahlen eingegeben : "; 15 for (n=0; n<i; n++) 16 cout << p[n] << " "; 17 delete [] p; // den vom Array belegten Speicher freigeben 18 return 0; 19 } 21 / 29

22 Dynamischer Speicher Anlegen und Löschen mit new und delete Freigeben von dynamisch erzeugtem Speicher Ein Array von Datenobjekten wird mit delete [] zeigername; freigegeben. Einige Besonderheiten sind bzgl. delete zu beachten: Dynamisch allokierter Speicher, auf den kein Zeiger mehr zeigt, ist unwiederbringlich verloren! C++ erkennt nicht, ob ein Speicher noch benutzt wird (wegen Laufzeiteffizienz). Dies ist in Java anders: die Java Virtual Machine überwacht den Heap und führt automatische ein Garbage Collection durch. delete darf ausschließlich auf Objekte angewendet werden, die mit new erzeugt wurden. delete auf einen NULL-Zeiger angewendet ist wirkungslos. Mit new erzeugte Datenobjekte unterliegen den Gültigkeitsregeln für Variablen nicht: sie existieren solange bis sie mit delete gelöscht werden. 22 / 29

23 Dynamischer Speicher Verkettete Listen Überblick 1 Zeiger Zeiger und Vektoren (Arrays) Rekursive dynamische Strukturen 2 Dynamischer Speicher Anlegen und Löschen mit new und delete Verkettete Listen 23 / 29

24 Dynamischer Speicher Verkettete Listen Verkettete Listen In diesem Abschnitt werden einfach verkettete Listen als rekursive, dynamische Datenstruktur vorgestellt. Dabei handelt es sich um ein oder mehrere structs, bei dem ein Element der Struktur auf ein Objekt des gleichen Typs zeigt. 1 struct knoten { 2 int info ; 3 struct knoten * next ; 4 } Listenelemente lassen sich dann wie folgt verketten: 24 / 29

25 Dynamischer Speicher Verkettete Listen Verwendung der verketteten Liste 1 # include <iostream > 2 using namespace std; 3 4 struct knoten { 5 int info ; 6 struct knoten * next ; 7 } *anfang, * ende ; 8 9 int main () { 10 anfang = ende = NULL ; // Leere Liste anlegen 11 int eingabe = 0; 12 do { 13 cout << " Integer ( Abbruch mit negativem Wert ): "; 14 cin >> eingabe ; 15 if ( eingabe >= 0) einfuegen ( eingabe ); // siehe Folie } while ( eingabe >= 0); 17 ausgeben (); // siehe Folie cout << " Integer, der geloescht werden soll : "; 19 cin >> eingabe ; 20 struct knoten *p = suchen ( eingabe ); // siehe Folie if (p!= NULL ) loeschen (p); // siehe Folie else cout << eingabe << " nicht in Liste vorhanden!" << endl ; 23 ausgeben (); // siehe Folie return 0; 25 } 25 / 29

26 Dynamischer Speicher Verkettete Listen Einfügen eines neuen Knotens am Ende der Liste 1 void einfuegen ( int x) { // einfuegen am Ende der Liste 2 struct knoten *p = new knoten ; // erzeuge neuen Knoten 3 p-> info = x; // Infowert wird x 4 p->next = NULL ; // next - Wert mit NULL initialisieren 5 if ( anfang == NULL ) { // Falls Liste leer 6 anfang = p; 7 ende = p; 8 } else { // Liste nicht leer 9 ende ->next = p; // einfuegen am Ende 10 ende = p; // neues Ende 11 } 12 } 26 / 29

27 Dynamischer Speicher Verkettete Listen Ausgeben der Listeninformationen 1 void ausgeben () { // ausgeben von Anfang bis Ende 2 struct knoten *p = anfang ; // p zeigt auf aktuellen Knoten 3 cout << " Liste : "; 4 while (p!= NULL ) { 5 cout << p->info << " "; // Ausgabe Info - Bereich 6 p = p-> next ; // p auf Folgeelement setzen 7 } 8 cout << endl ; 9 } 27 / 29

28 Dynamischer Speicher Verkettete Listen Suchen nach einem Knoten mit bestimmtem Wert Das Suchen nach einem Knoten ist ähnlich wie das Durchlaufen der Liste. Nur geben wir hier nicht jedes info-element aus, sondern prüfen dessen Wert. Stimmt dieser mit dem Gesuchten überein, haben wir den passenden Knoten gefunden und können diesen zurückgeben. Falls nicht, wird NULL zurückgegeben, auf das dann im aufrufenden Programm reagiert werden kann. 1 struct knoten * suchen ( int x) { // sequentielles Suchen 2 struct knoten *p = anfang ; 3 while (p!= NULL ) { 4 if (p-> info == x) return p; // gefunden! 5 else p = p-> next ; // p auf Folgeelement setzen 6 }// while 7 return NULL ; // nicht gefunden 8 } 28 / 29

29 Dynamischer Speicher Verkettete Listen Löschen eines Knotens und Neuverketten der Liste 1 void loeschen ( struct knoten *p) { 2 struct knoten *p1 = anfang ; 3 if (p == anfang ) { 4 anfang = anfang ->next ; // neuer Anfang 5 delete p; 6 return ; // vorzeitiges Beenden der Funktion 7 } 8 while (p1 ->next!= p) // suche Vorgaenger 9 p1 = p1 ->next ; // gehe zum naechsten Knoten 10 p1 ->next = p->next ; // verkette neu (p- Knoten ueberspringen ) 11 delete p; 12 } 29 / 29