Technische Infor matik 2 C/C++-Kurs. Pointer und Arrays AG Rechner netze 2.1

Transkript

1 Technische Infor matik 2 C/C++-Kurs Pointer und Arrays 2007 AG Rechner netze 2.1

2 Pointer in C Pointer (Zeiger) Wichtiges Konzept in C/C++ InJava versteckt Umdenken erforder lich AmAnfang durchaus schwierig zu verstehen Pointer "zeigt auf ein Objekt" Pointer-Var iable enthält die Speicher-Adresse, ander das Objekt liegt Typ des Pointers impliziert Typ des Objekts eingesetzt u.a. bei dynamischer Allozierung von Speicher dito beim direkten Zugriff auf Hardware nicht unnötig einsetzen für Grunddatentypen und lokale Objekte (vs. Java) 2007 AG Rechner netze 2.2

3 Pointer in C Pointer auf Objekt herstellen: & Unärer Operator (Adreßoperator) Anwendbar auf Var iablen und Arrayelemente int i, a[10]; unsigned u; int *ptr; (pointer auf integer) ptr = &i; ptr = &u; // OK // FEHLER: Falscher Typ ptr = &a[0]; // OK Nicht auf Wer te ptr = &3; // FEHLER ptr = &(i+3); // FEHLER Nicht auf Registervariablen 2007 AG Rechner netze 2.3

4 Pointer in C Dereferenzieren eines Pointers: * Unärer Operator, Umkehr ung von & Liefer t Objekt, auf das der Pointer zeigt int i, j = 5; ptr = &i; // ptr Pointer auf Integer *ptr = 1; // i ist jetzt 1 ptr = &j; i = *ptr; // i ist jetzt 5 *ptr += 2; // j ist jetzt 7 ++*ptr; // j ist jetzt 8 (*ptr)++; // j ist jetzt 9 i = ptr; // FEHLER: Falscher Typ Deklaration von Pointer-Variablen int *ptr; *ptr ist int char *p, *q; *p und *q sind char double *dp, d d ist kein Pointer! 2007 AG Rechner netze 2.4

5 Pointer in C Pointer und Funktionsargumente Argumentübergabe in C call-by-value Pointer ermöglichen call-by-reference Java macht dies automatisch Beispiel (Austausch von zwei int-var iablen): void swap(int *p, int *q) { int temp = *p; *p = *q; *q = temp; } Benutzung mit Adreßoperator : int x, y, a[10]; swap(&x, &y); swap(&a[0], &a[1]); C++: Referenztypen (später...) 2007 AG Rechner netze 2.5

6 Pointer in C Pointer-Argumente als Ausgabe-Parameter /* Integer von Eingabe nach *ret lesen; Returnwert false wenn * keine Zahl da, sonst true. BUG: liest das nächste Zeichen weg */ bool getint(int *ret) { char c; bool ok = false; for (*ret = 0; cin.get(c) && isdigit(c); ) { *ret = 10 * *ret + (c - 0 ); ok = true; } return ok; } void f() { } int i; if (getint(&i)) {... } 2007 AG Rechner netze 2.6

7 Pointer in C Null-Pointer Spezieller Pointer-Wer t Steht für zeigt auf nichts darf nicht dereferenzier t werden Implizite Typumwandlung 0 Pointer Integer 0 darf an Pointer zugewiesen werden Pointer kann mit 0 verglichen werden (typ *)0 kann nie valide Adresse sein Implizite Typumwandlung Pointer bool bei Expressions Umtypung automatisch: char *p = 0; if (p!= 0) oder : if (p) Wird in C oft als NULL geschrieben (<stdio.h>) #define NULL AG Rechner netze 2.7

8 Pointer in C void*: generischer Pointer typ Cast von Pointer nach void* und zurück erlaubt T* void* T* ist invariant Ausnahme: Funktionspointer void* kann nicht dereferenzier t werden int i; int *ip = pointer to integer; char *cp = pointer to character; void *vp; vp = ip; // OK vp = cp; // OK C++: keine implizite Konvertier ung von void* ip = vp; // FEHLER: unsicher (ANSI C: OK) ip = (int *)vp; // OK 2007 AG Rechner netze 2.8

9 Pointer und Arrays Arrays imprinzip aus Java bekannt Enger Zusammenhang Pointer/Arrays Wird häufig falsch verstanden Statt Array-Indizier ung auch Pointer-Zugriff möglich (für Anfänger) schwieriger verständlich Array-Indizier ung über Pointer möglich Grundlage: Pointer können auf Array-Elemente zeigen Pointer enthält Adresse von Array-Element int a[10], *p; p = &a[0]; /* zeigt auf erstes Element */ Dereferenzier ung liefer t Inhalt von Array-Element *p a[0] 2007 AG Rechner netze 2.9

10 Pointer und Arrays Arithmetische Operationen auf Pointer : p+1 zeigt auf nächstes Array-Element p+i zeigt auf i-tes Element hinter p p i zeigt auf i-tes Element vor p int a[10], *p; p = &a[0]; // zeigt auf a[0] *p // liefert a[0] *(p+1) // liefert a[1] *(p+i) // liefert a[i] p += 5; *p // liefert a[5] *(p-1) // liefert a[4] *(p-i) // liefert a[5-i] Abhängig vom Typ 1ist nicht unbedingt ein Byte / die Größe einer Pointer var iablen 1ist die Bytezahl des Types auf die der Pointer zeigt 2007 AG Rechner netze 2.10

11 Pointer und Arrays Der Trick Array ist identisch mit Adresse seines ersten Elements: p = &a[0]; kann geschrieben werden als: p = a; Zwei äquivalente Schreibweisen Array/Index- entspricht Pointer/Offset-Ausdr uck Generell gilt: a[i] identisch mit *(a+i) &a[i] identisch mit a+i &a[0] identisch mit a Auch Pointer kann indiziert werden: p[i] identisch mit *(p+i) Negativer Index ebenfalls möglich: p[ 1] identisch mit *(p 1) 2007 AG Rechner netze 2.11

12 Pointer und Arrays Compiler verwandelt Array-Name in Pointer auf erstes Element Pointer und Arrays sind aber nicht dasselbe Namen von Array-Var iablen sind konstant: int a[10]; a++; /* nicht erlaubt! */ a = p; /* nicht erlaubt! */ 2007 AG Rechner netze 2.12

13 Pointer und Arrays Funktions-Argumente Auch hier Array/Pointer-Umwandlung Länge eines Strings (char-array) berechnen: int strlen(char *s) { int n; } for (n = 0; *s!= \0 ; s++) n++; return n; Funktion arbeitet auf lokaler Kopie des Pointers Aufr uf mit Array oder Pointer : strlen("hi there!"); /* Konstante */ strlen(array); /* char array[80]; */ strlen(ptr); /* char *ptr; */ 2007 AG Rechner netze 2.13

14 Pointer und Arrays Deklaration des for malen Parameters: char s[]; oder : char *s; Argument wird immer in Pointer umgewandelt Deklaration als Pointer klarer 2007 AG Rechner netze 2.14

15 Pointer und Arrays Pointer-Vergleich Schleife über Array-Elemente (mit Pointer): int size = 7; int a[size], *p; for (p = &a[0]; p < &a[size]; p++) *p = 0; for (p = a; p < a+size; p++) // kürzer *p = 0; Pointer können verglichen werden (<, >,...) Beide Pointer sollten(!) in dasselbe Array zeigen Sonderfall: Pointer direkt hinter Array OK (&a[size]) == und!= immer definiert 2007 AG Rechner netze 2.15

16 Pointer und Arrays Es geht auch komplizier ter... // Beispiel: Speicheranforderung const int size = 10000; char buf[size]; char *bufp = buf; void *allocate(int n) { if (buf + size bufp >= n) { // passt bufp += n; return bufp n; // alter Wert } else return 0; } 2007 AG Rechner netze 2.16

17 Pointer und Arrays Pointerdifferenz Pointer dürfen subtrahier t werden Resultat ptrdiff_t (integer-typ) Anzahl der Elemente zwischen den Pointer n Beispiel: Vereinfachtes strlen: int strlen(char *s) { char *p = s; } while (*p!= \0 ) p++; return p s; Addition von Pointer n nicht erlaubt 2007 AG Rechner netze 2.17

18 Pointer und Arrays Character-Pointer und Strings Str ing-konstante ist Character-Array Wird automatisch mit \0 terminier t Wird in Pointer auf erstes Character verwandelt Bei Funktionsaufruf: speak("hello, world"); Funktion bekommt Pointer als Argument Bei Zuweisung: char *msg; msg = "this is a string"; Weist Pointer auf erstes Character zu Str ing wird nicht kopier t! 2007 AG Rechner netze 2.18

19 Pointer und Arrays Array versus Pointer bei Deklaration: char amsg[] = "hello"; char *pmsg = "hello"; amsg ist konstant, pmsg modifizierbar amsg enthält Speicherplatz für 6 chars pmsg enthält Speicherplatz für Adresse Erste Definition: 6 Bytes (Beispiel) Zweite Definition: 4+6 Bytes (Beispiel) 2007 AG Rechner netze 2.19

20 Pointer und Arrays Character-Pointer und Funktionen Chat keine Operatoren für Stringverarbeitung Str ingverarbeitung über Librar yfunktionen Beispiel: strcpy(s,t) kopier t Str ing t nach s Array-Version von strcpy: void strcpy(char *s, char *t) { int i = 0; } while ((s[i] = t[i])!= \0 ) i++; Pointer-Version von strcpy: while ((*s = *t)!= \0 ) { s++; t++; } Noch kürzere Version: while (*s++ = *t++); 2007 AG Rechner netze 2.20

21 Der Freispeicher Bei C/C++ muß sich der Programmierer um die Speicher verwaltung kümmern Speicherallozier ung zur Laufzeit mit new int *p = new int;... delete p; // wir müssen selbst aufräumen... Speicher muß wieder freigegeben werden Ansonsten Memory-Leak Kein Garbage-Collector wie in Java Für Grundtypen wenig nützlich später Array-Allozier ung int *p = new int[n];... delete[] p; n kann beliebiger Ausdr uck sein 2007 AG Rechner netze 2.21

22 Der Freispeicher Beispiel: strdup-implementierung: char *strdup(char *s) { int len = strlen(s) + 1; // +1: Null-Byte! char *p = new char[len]; if (p!= 0) strcpy(p, s); return p; } Freigabe mit delete char *p = strdup("hello"); delete[] p; Wichtig: delete delete[] gibt den Speicher eines Objektes frei gibt Speicher eines Arrays von Objekten frei InC: void *malloc(int) free(void *) reser viert Speicher gibt Speicher frei 2007 AG Rechner netze 2.22

23 Type-Qualifier: const und volatile const Deklar iert Objekt als read-only Initialisier ung er laubt, Zuweisung verboten Ermöglicht Compiler Erzeugung effizienten Codes muß nicht unbedingt Speicherplatz anlegen Initialisier ung kann oft zur Compilezeit ausgewertet werden Var iable kann in read-only-speicher abgelegt werden Ermöglicht Compiler bessere Konsistenzprüfungen Deklaration von const-var iablen: const double v[] = { 1.3, 2.0, 0, 3.8 }; const int year = 90; year = 92; /* Nicht erlaubt */ v[1] = 7.2; /* Nicht erlaubt */ Nützlich auch bei Funktionsargumenten: void strcpy(char *to, const char *from); 2007 AG Rechner netze 2.23

24 Type-Qualifier: const und volatile const und Pointer-Variablen const kann angegeben werden für: die Pointer-Var iable selbst das Objekt, auf das der Pointer zeigt Pointer auf read-only-zeichen: const char *p = "hello"; p[1] = a ; /* Fehler */ p = "hi!"; /* Erlaubt */ read-only-pointer auf Zeichen: char * const p = "hello"; p[1] = a ; /* Erlaubt, kann aber zur Laufzeit einen Speicherzugriffs-Fehler zur Folge haben. Besser char * const p = strdup("hello"); */ p = "hi!"; /* Fehler */ 2007 AG Rechner netze 2.24

25 Type-Qualifier: const und volatile const und Pointer-Variablen (2) read-only-pointer auf read-only-zeichen: const char * const p = "hello"; p[1] = a ; /* Fehler */ p = "hi!"; /* Fehler */ Pointer auf const-typ darf auf nicht-const-objekt zeigen: int a = 1; const int *p; p = &a; // OK *p = 2; // Fehler a = 2; // OK Wichtig bei Funktionsargumenten: int strlen(const char *str); char mystring[] = "hello"; int len = strlen(mystring); 2007 AG Rechner netze 2.25

26 Type-Qualifier: const und volatile const und Pointer-Variablen (3) Zuweisung an const-objekt über Pointer auf nicht-const-objekt undefiniert Type-Qualifier volatile Objekt ändert sich ohne Wissen des Compilers Zuweisung in Signal-Handler Zuweisung durch Hardware (Device-Register) Kombination von const und volatile möglich 2007 AG Rechner netze 2.26