Grundlagen der Informatik 11. Zeiger

Transkript

1 11. Zeiger Motivation Zeiger und Adressen Zeiger und Funktionen Zeiger und Arrays Dynamische Objekte Grundlagen der Informatik (Alex Rempel) 1

2 Motivation Dynamische Speicherverwaltung Oft müssen große Speicherblöcke verwaltet werden Eine Speicherarithmetik wird gebraucht, um den Adressraum im Code komfortabel duchzugehen Beispiel Mehrdimensionale Arrays sind sehr unhandlich, stattdessen wird oft ein großer eindimensinaler Array verwendet Vorteil: Parameterübergabe an Funktionen vereinfacht int iarray[12][5]; int i = iarray[3][2]; int iarray[60]; // 12x5 int i = iarray[3*5+2]; Grundlagen der Informatik (Alex Rempel) 2

3 Motivation Dynamische Speicheranpassung Arrays müssen eine feste Größe haben, aber oft werden Arrays mit dynamischer Größe gebraucht Beispiel: Benutzer gibt Anzahl n der einzugebenden Elemente ein Array wird erst danach dynamisch mit der Größe n erzeugt Dynamische Parameterübergabe Ferner auch die Möglichkeit, Arrays zurückzugeben Etc. Grundlagen der Informatik (Alex Rempel) 3

4 Zeiger und Adressen Zeiger (Pointer) sind Variablen type * name; Inhalt der Variable: Adresse im Speicher oder NULL Adresse im Speicher ist bei 32b Systemen eine 32b große Zahl Ändert sich der Inhalt, zeigt die Variable auf eine andere Speicherzelle Inhalt NULL bedeutet, dass die Variable auf nichts zeigt Beim Anwenden von Rechenoperatoren auf den Zeiger kann der Speicher entsprechend durchlaufen werden Beim Dereferenzieren eines Zeigers bekommt man die Variable, auf welche der Zeiger zeigt Der type des Zeigers gibt dabei den Typ der Variable an Grundlagen der Informatik (Alex Rempel) 4

5 Deklaration Grundlagen der Informatik Zeiger und Adressen Von rechts nach links interpretieren: type * name; Variable name ist ein Zeiger auf etwas vom Typ type Initialisierung Zuweisung einer Adresse: ipointer zeigt nun auf Variable inumber Falls nicht sofort zugewiesen wird, sollte immer die Initialisierung auf NULL erfolgen (sonst Fehlerquelle): int* ipointer = NULL; int inumber = 42; int* ipointer = &inumber; Grundlagen der Informatik (Alex Rempel) 5

6 Zeiger und Adressen double* ppointer = NULL; Name Adresse Inhalt ppointer 0x0031FB60 0x == &ppointer == ppointer double* ppointer = NULL; double dnumber = 0.2; dnumber 0x0031FC == &dnumber == dnumber double* ppointer = NULL; double dnumber = 0.2; ppointer = &dnumber; ppointer 0x0031FB60 0x0031FC50 == &ppointer == ppointer == &dnumber dnumber 0x0031FC == &dnumber == ppointer == dnumber == *ppointer Grundlagen der Informatik (Alex Rempel) 6

7 Zeiger und Adressen double* ppointer = NULL; double dnumber = 0.2; ppointer = &dnumber; Name Adresse Inhalt ppointer 0x0031FB60 0x0031FC50 == &ppointer == ppointer == &dnumber dnumber 0x0031FC == &dnumber == ppointer == dnumber == *ppointer double* ppointer = NULL; double dnumber = 0.2; ppointer = &dnumber; *ppointer = *ppointer + 1.3; ppointer 0x0031FB60 0x0031FC50 == &ppointer == ppointer == &dnumber dnumber 0x0031FC == &dnumber == ppointer == dnumber == *ppointer Dereferenzierung Grundlagen der Informatik (Alex Rempel) 7

8 Zeiger und Adressen p is saved in 0x0031FB60 and points to 0x (no value)...dnumber=0.2 in address 0x0031FC50 #include <iostream> p is saved in 0x0031FB60 and points to 0x0031FC50 (value = 0.2) #include <iomanip> using namespace std; const unsigned char g_ucaddresswidth = 8; void printpointer(double*& p) { cout << "p is saved in 0x" << setw(g_ucaddresswidth) << &p << " and points to 0x" << setw(g_ucaddresswidth) << p; if (p!= NULL) cout << " (value = " << *p << ")" << endl; else cout << " (no value)" << endl; void main() { cout << hex << setfill('0'); // set format for all cout double* ppointer = NULL; printpointer(ppointer); // pointing to NULL double dnumber = 0.2; cout << "...dnumber=" << dnumber << " in address 0x" << setw(g_ucaddresswidth) << &dnumber << endl; ppointer = &dnumber; printpointer(ppointer); // pointing to dnumber Grundlagen der Informatik (Alex Rempel) 8

9 Zeiger und Adressen Übung für zu Hause: welche Ausgabe wird erzeugt? (Hinweis: Adressen können nicht vorhergesagt werden) #include <iostream> using namespace std; void main() { double d1 = 1, d2 = 2; const double dconst1 = 11, dconst2 = 12; double* pdouble = &d1; const double* pconstdouble = &dconst1; double* const pdoubleconst = &d2; const double* const pconstdoubleconst = &dconst2; cout << d1 - *pdouble << "..." << *pdouble << "..." << pdouble << endl; cout << *pconstdouble << "..." << pconstdouble << endl; cout << *pdoubleconst << "..." << pdoubleconst << endl; cout << *pconstdoubleconst << "..." << pconstdoubleconst << endl; pconstdouble = &dconst2; cout << *pdouble + *pconstdouble + *pdoubleconst + *pconstdoubleconst << endl; Grundlagen der Informatik (Alex Rempel) 9

10 Zeiger und Adressen Merken: Zeiger immer initialisieren Immer mit NULL initialisieren, falls nicht gleich zugewiesen, sonst gibt es folgende Auswirkungen: Inhalt eines nicht initialisierten Zeigers ist undefiniert Die Zeigervariable zeigt somit auf eine unbekannte Adresse Lesen und Schreiben wird auf fremden Speicher ausgeführt int* p; cout << p << "=" << *p << endl; *p = 42; cout << p << "=" << *p << endl; Grundlagen der Informatik (Alex Rempel) 10

11 Zeiger und Adressen Merken: Zeiger immer initialisieren Immer mit NULL initialisieren, falls nicht gleich zugewiesen, sonst gibt es folgende Auswirkungen: Inhalt eines nicht initialisierten Zeigers ist undefiniert Die Zeigervariable zeigt somit auf eine unbekannte Adresse Lesen und Schreiben wird auf fremden Speicher ausgeführt p zeigt auf eine unbekannte Adresse int* p; cout << p << "=" << *p << endl; *p = 42; cout << p << "=" << *p << endl; 759AB6F0= AB6F0=42 Im Release Modus ausführbar Es wird eine Adresse gelesen und geschrieben, die zu diesem Zeitpunkt sehr wahrscheinlich einer anderen Variable gehört Grundlagen der Informatik (Alex Rempel) 11

12 Zeiger und Adressen Konstante Zeiger und Zeiger auf Konstanten Zeiger auf Konstanten, Beispiel: const int i = 4; Somit kann und darf i nicht mehr geändert werden Folgendes funktioniert also nicht: Sonst könnte man so i ändern: Richtige Deklaration: int* p = &i; *p = 7; const int* p = &i; Konstante Zeiger double* const p = &dnumber; Zeiger wird sofort initialisiert und wird nicht mehr geändert Der Wert der Variable auf die er zeigt kann aber verändert werden (außer die ist auch konstant) Grundlagen der Informatik (Alex Rempel) 12

13 Zeiger und Adressen Zeiger auf Zeiger (auf Zeiger...) Zeiger speichern Adressen von anderen Variablen Zeiger selbst sind auch Variablen Zeiger können also auch auf andere Zeiger zeigen Tipp: Deklaration immer von rechts nach links lesen #include <iostream> #include <string> using namespace std; strtext 0x... What the hell?! pempty 0x... &strtext void main() { string* pempty = NULL; string** ppstring = &pempty; string strtext = "What the hell?!"; *ppstring = &strtext; ppstring 0x... &pempty cout << *pempty << endl; What the hell?!...am Ende... Grundlagen der Informatik (Alex Rempel) 13

14 Zeiger und Funktionen Parameterübergabe mit Zeigern wie mit Variablen Wertübergabe und Referenzübergabe möglich #include <iostream> using namespace std; void IncrementValueAndMakeNULL_WRONG(int* p) { *p = *p + 1; p = NULL; void IncrementValueAndMakeNULL_CORRECT(int*& p) { *p = *p + 1; p = NULL; void main() { int i = 1; int* p1 = &i; int* p2 = &i; cout << "p1=" << p1 << ", p2=" << p2 << ", i=" << i << endl; IncrementValueAndMakeNULL_WRONG(p1); IncrementValueAndMakeNULL_CORRECT(p2); cout << "p1=" << p1 << ", p2=" << p2 << ", i=" << i << endl; p ist eine neue Variable, daher wirkt sich p=null nicht auf p1 unten aus p ist eine Referenz auf p2, also wirkt sich p=null auch auf p2 unten aus p1=0037f7c0, p2=0037f7c0, i=1 p1=0037f7c0, p2= , i=3 Grundlagen der Informatik (Alex Rempel) 14

15 Zeiger und Funktionen Rückgabewert einer Funktion darf ein Zeiger sein #include <iostream> using namespace std; pmax value = 15 int* getmax(int& a, int& b) { if (a > b) return &a; return &b; void main() { int i1 = 3, i2 = 15; int* pmax = getmax(i1,i2); cout << "pmax value = " << *pmax << endl; Grundlagen der Informatik (Alex Rempel) 15

16 Zeiger und Funktionen Rückgabewert einer Funktion darf ein Zeiger sein Achtung: beim Zurückgeben eines Zeigers immer darauf achten, dass zurückgegebene Adresse im Zeiger auch nach dem Aufruf der Funktion gültig ist #include <iostream> using namespace std; int* getmax(int a, int b) { if (a > b) return &a; return &b; pmax value = Unter der zurückgegebenen Adresse in pmax gibt es keine Variable mehr, weil a und b nur in der Funktion getmax existierten void main() { int i1 = 3, i2 = 15; int* pmax = getmax(i1,i2); cout << "pmax value = " << *pmax << endl; Grundlagen der Informatik (Alex Rempel) 16

17 Zeiger und Arrays Name eines Arrays ist Zeiger auf die Startadresse Jede Indexoperation auf ein Array kann somit auch in Form einer Zeigeroperation erfolgen Im Allgemeinen effizienter, aber schwerer zu verstehen #include <iostream> using namespace std; 3 == 3 4 == 4 1 == 1 void main() { const int isize = 3; int ii[isize] = {3,4,1; int* p = ii; // == &ii[0] for (int i=0; i < isize; ++i) cout << ii[i] << " == " << *(p+i) << endl; Zeigerarithmetik, p+2 bedeutet z.b.: gehe im Speicher von Adresse in p 2*sizeof(int) weiter (int* p). Klappt, weil Arrays zusammenhängend gespeichert werden. Grundlagen der Informatik (Alex Rempel) 17

18 Zeiger und Arrays Zeigerarithmetik Operationen (immer in Abhängigkeit vom Zeigertyp): Zeiger plus/minus Ganzzahl, Zeiger minus Zeiger, Vergleich von Zeigern #include <iostream> #include <iomanip> using namespace std; ( )(A)(B)( ) void printmemorychars(unsigned char* pfirstincl, unsigned char* plastexkl) { while(pfirstincl!= plastexkl) { cout << "(" << *pfirstincl << ")"; ++pfirstincl; cout << endl; void main() { cout << hex << setfill('0'); unsigned char cc[] = {'\0','A','B','\0'; int isizechars = sizeof(cc)/sizeof(unsigned char); // 4 printmemorychars(cc,cc+isizechars); Grundlagen der Informatik (Alex Rempel) 18

19 Zeigerarithmetik Zeiger und Arrays ( )(A)(B)( ) (0x4100)(0x0042) #include <iostream> #include <iomanip> using namespace std; // from other file void printmemorychars(unsigned char* pfirstincl, unsigned char* plastexkl); void printmemoryshorts(unsigned short* pfirstincl, unsigned short* plastexkl) { while(pfirstincl!= plastexkl) { cout << "(0x" << setw(4) << *pfirstincl << ")"; ++pfirstincl; cout << endl; void main() { cout << hex << setfill('0'); unsigned char cc[] = {'\0','A','B','\0'; int isizechars = sizeof(cc)/sizeof(unsigned char); // 4 int isizeshorts = sizeof(cc)/sizeof(unsigned short); // 2 printmemorychars(cc,cc+isizechars); printmemoryshorts((unsigned short*)cc,(unsigned short*)cc+isizeshorts); Grundlagen der Informatik (Alex Rempel) 19

20 Zeigerarithmetik Grundlagen der Informatik Zeiger und Arrays Kann sehr effizent, aber sehr unlesbar sein, Ablauf hier in while: Zuweisung '=': kopiere aktuelles Zeichen aus *pfrom nach *pto Post-Inkrement 'pfrom++': pfrom auf nächstes Zeichen Bedingung auf Zeichen in *pto: true solange nicht '\0' Post-Inkrement 'pto++': pto auf nächstes Zeichen #include <iostream> using namespace std; void copytext(unsigned char* pfrom, unsigned char* pto) { while( *pto++ = *pfrom++ ); void main() { unsigned char uctext1[10] = "Lolcat!"; unsigned char uctext2[10] = {0; cout << "'" << uctext1 << "', '" << uctext2 << "'" << endl; copytext(uctext1,uctext2); cout << "'" << uctext1 << "', '" << uctext2 << "'" << endl; 'Lolcat!', '' 'Lolcat!', 'Lolcat!' Grundlagen der Informatik (Alex Rempel) 20

21 Zeiger und Arrays Array als Funktionsparameter mit Zeigern #include <iostream> using namespace std; Length 'Lolcat!' = 7 unsigned long getlength(unsigned char* ptext) { unsigned long ullength = 0; while (*ptext!= '\0') { ++ptext; ++ullength; return ullength; void main() { unsigned char uctext[] = "Lolcat!"; cout << "Length '" << uctext << "' = " << getlength(uctext) << endl; Grundlagen der Informatik (Alex Rempel) 21

22 Zeiger und Arrays Array als Funktionsparameter mit Zeigern #include <iostream> using namespace std; Parameter als Array und als Zeiger gültig Length 'Lolcat!' = 7 unsigned long getlength(unsigned char ptext[]) { unsigned long ullength = 0; while (*ptext!= '\0') { ++ptext; ++ullength; return ullength; void main() { unsigned char uctext[] = "Lolcat!"; cout << "Length '" << uctext << "' = " << getlength(uctext) << endl; Grundlagen der Informatik (Alex Rempel) 22

23 Zeiger und Arrays Array als Funktionsparameter mit Zeigern Beispiel mit Nutzung der Zeigerarithmetik #include <iostream> using namespace std; Length 'Lolcat!' = 7 Length 'cat!' = 4 unsigned long getlength(unsigned char* ptext) { unsigned long ullength = 0; while (*ptext++!= '\0') ++ullength; return ullength; Zeigerarithmetik void main() { unsigned char uctext[] = "Lolcat!"; cout << "Length '" << uctext << "' = " << getlength(uctext) << endl; cout << "Length '" << uctext+3 << "' = " << getlength(uctext+3) << endl; Grundlagen der Informatik (Alex Rempel) 23

24 Dynamische Objekte Es muss eine Möglichkeit geben, neue Objekte, die es zur Compilezeit (beim Programmieren) noch nicht gab, dynamisch zur Laufzeit zu erzeugen Beispiel: Array erst nach der Eingabe der Größe erzeugen Programmspeicher wird hierfür aufgeteilt: Statischer Teil für Objekte zur Compilezeit Dynamischer Teil für Objekte zur Laufzeit Permanenter Teil für globale und statische Objekte Permanenter Teil für den Programmcode Grundlagen der Informatik (Alex Rempel) 24

25 Programmspeicher Dynamische Objekte Code Permanente Objekte global static Heap Objekte dynamisch freier Bereich Stack Objekte Auto Variablen Parameter 0x xFFFFFFFF zur Compilezeit berechnet Objekte auf dem Stack Werden automatisch erzeugt Variable in einem Block angelegt Werden automatisch freigegeben Block wird abgeschlossen, lokale Variable wird freigegeben Objekte auf dem Heap Müssen manuell erzeugt und freigegeben werden Grundlagen der Informatik (Alex Rempel) 25

26 Dynamische Objekte Objekte auf dem Stack (Zugriff über Variablen) Vorteil: Objekte werden automatisch erzeugt und freigegeben Nachteil: Objektanzahl muss zur Pogrammierzeit bekannt sein if (inumber > 6) { int a = 8; Für Variable a wird hier automatisch Speicher auf dem Stack reserviert Variable a ist nur in dem lokalen Block gültig, der Speicher auf dem Stack wird am Ende des Block automatisch freigegeben Grundlagen der Informatik (Alex Rempel) 26

27 Dynamische Objekte Objekte auf dem Heap (Zugriff über Zeiger) Vorteil: Objektanzahl darf beim Programmieren unbekannt sein Nachteil: Objekte müssen manuell freigegeben werden Syntax: erzeugen mit new, freigeben mit delete if (inumber > 6) { int* a = new int(8); delete a; Für Zeigervariable a wird hier automatisch Speicher auf dem Stack reserviert, aber die Variable selbst zeigt auf einen dynamisch erzeugten neuen Speicher, in dem ein int gespeichert wird Gibt den Speicher frei, auf den Zeiger a zeigt Grundlagen der Informatik (Alex Rempel) 27

28 Dynamische Objekte Ein dynamisch auf dem Heap erzeugtes Objekt ist einfach nur ein Teil des Speichers, welcher je nach Zeigertyp unterschiedlich interpretiert wird #include <iostream> #include <iomanip> using namespace std; void printnumber(unsigned int& uinumber) { cout << "0x" << hex << setfill('0') << setw(8) << uinumber << endl; void main() { unsigned int inumber = 0x0F0F; unsigned int* pnumber = &inumber; printnumber(*pnumber); pnumber = new unsigned int; // 4 bytes reserved without initialization printnumber(*pnumber); *pnumber = 0xABCD; // setting int value as usual printnumber(*pnumber); delete pnumber; // freing reserved 4 bytes from heap memory 0x00000f0f 0x x0000abcd Grundlagen der Informatik (Alex Rempel) 28

29 Dynamische Arrays #include <iostream> using namespace std; void inputdata(int* pdata, int isize) { while (isize--) cin >> *pdata++; Dynamische Objekte void printdata(int ii[], int isize) { while (isize--) cout << " --> " << *ii++ << endl; void main() { int isize = 0; cout << "How many elements (1..10)? "; cin >> isize; if (isize > 10) isize = 10; else if (isize < 1) isize = 1; int* parray = new int[isize]; inputdata(parray,isize); printdata(parray,isize); delete [] parray; How many elements (1..10)? > 35 --> > 2 --> 9 Grundlagen der Informatik (Alex Rempel) 29

30 Dynamische Objekte Regeln bei dynamischen Objekten delete darf nur auf Objekte angewendet werden, welche mit new erzeugt wurden delete auf einen NULL Zeiger ist wirkungslos Objekte, die mit new erzeugt wurden, werden nicht automatisch verwaltet und bestehen daher nicht bis zum Ende eines Blocks (Gültigkeitsbereich), sondern bis sie mit delete freigegeben werden Grundlagen der Informatik (Alex Rempel) 30

31 Dynamische Objekte Gefahren bei dynamischen Objekten Heap: Objekt muss mit genau einem new erzeugt und mit genau einem delete freigegeben werden Kein Zeiger zeigt auf das Objekt... gibt es keinen Zugriff mehr auf den Inhalt kann das Objekt nicht mehr freigegeben werden (engl. leak) Mehrere Zeiger zeigen auf das Objekt... darf nur ein Mal freigegeben werden { int* a = new int; // hier memory leak int* a = new int; int* b = a; delete a; *b = 4; // fremder Speicher danach darf kein Zugriff mehr auf dessen Speicher erfolgen Grundlagen der Informatik (Alex Rempel) 31