Algorithmen und Datenstrukturen Zeiger und Strukturen. M. Herpers, Y. Jung, P. Klingebiel

Transkript

1 Algorithmen und Datenstrukturen Zeiger und Strukturen M. Herpers, Y. Jung, P. Klingebiel 1

2 Lernziele Zeiger in C kennen und anwenden können Wissen, wie der Speicherplatz in C verwaltet wird Den Zusammenhang zwischen Arrays und Zeigern kennen und anwenden können Bitmanipulationen und ihre Anwendung kennen C-Strukturen (Records) kennen und anwenden können 2

3 ZEIGER (POINTER) 3

4 Wo steht was im Speicher? #include <stdio.h> int main(int argc, char *argv[]) { int a = 10; int b = 20; return 0; } 4

5 Wo steht was im Speicher? Ein ganz einfaches Programm! Wie sieht es im Speicher aus? 0022EE00 10 a 0022FFAB 20 b Speicheradressen Variablennamen Speicherinhalte 5

6 Wo steht was im Speicher? #include <stdio.h> int main(int argc, char *argv[]) { int a = 10; int b = 20; int *azeiger = &a; /* Pointer azeiger */ int *bzeiger = &b; /* Pointer bzeiger */ return 0; } 6

7 Wo steht was im Speicher? Wie sieht es im Speicher aus? bzeiger 0022FFAB &a 0022EE00 10 a azeiger 0022EE00 &b 0022FFAB 20 b Adressen 7

8 Zeiger bzw. Pointer Pointer ist Variable, die Speicheradresse hält Zugreifen auf Daten an dieser Speicheradresse heißt Dereferenzieren eines Pointers In Funktionen sind Variablen aus aufrufender Funktion über Pointer veränderbar: Call-by-Reference 8

9 Pointer Pointer hält Adresse einer Speicherzelle Speicheradresse ptr 0x7b03a928 j int main() { int j = 12; } int *ptr = &j; printf("%d\n", *ptr); j = 24; printf("%d\n", *ptr); printf("%p\n", ptr); Was wird ausgegeben? 9

10 Pointer Null-Pointer kann nicht dereferenziert werden #include <stdio.h> ptr j 12 int main() { int j = 12; int *ptr = NULL; } printf("%d\n", *ptr); return 0; // crash! Segmentation violation (core dumped) 10

11 Zeiger-Beispiel: Einzelschrittansicht Zugriff auf Variable mit Pointer 11

12 Ausgabe Werte und Adressen int main(int argc, char *argv[]) { int a = 10; int *azeiger = &a; int b = 20; int *bzeiger = &b; printf("%d \t %d\n", *azeiger, *bzeiger); // Werte // Speicheradressen, wo die Werte stehen printf("%p \t %p\n", azeiger, bzeiger); // Adresse der Adressen (d.h. der Pointer) printf("%p \t %p\n", &azeiger, &bzeiger); } 12

13 Adressen Werte und Pointer Konkret: Wie sieht es im Speicher aus? Beispielausgabe: 0022FF FF6C bzeiger 0022FF6C 20 b 0022FF FF74 azeiger 0022FF74 10 a 13

14 Zeiger auf void void* Bezeichnet Zeiger, der jeden anderen Zeiger ersetzen kann, ohne dass Information verloren geht Jeder Zeiger kann in void* verwandelt werden Platzhalter für Zeiger Bsp. (Type Cast): int a = 11; char *ca = NULL; void *ptr; ptr = (void*)&a; ptr = (void*)ca; 14

15 Speicherverwaltung in C Geschieht mit Hilfe von Bibliotheksfunktionen #include <stdlib.h> Speicherblock anfordern mit Funktion malloc() void* malloc (size_t size); Ziemlich low-level, benötigt nur gewünschte Größe des (zusammenhängenden) Speicherbereichs in Byte Bsp. dynamisch Platz für 10 Short-Werte allozieren: unsigned short *ptr = (unsigned short*)malloc(10 * sizeof(unsigned short)); Kein Unterschied zwischen Einzelwerten und Arrays! Speicherblock freigeben mit Funktion free() void free(void *ptr) 15

16 Speicherverwaltung in C Speicher anfordern (hier für einen Integer) int *ptr = (int*)malloc(sizeof(int)); if (ptr!= NULL) { *ptr = 1024; } else { printf("kein Speicher verfuegbar!\n"); } Speicher freigeben if (ptr!= NULL) { free(ptr); ptr = NULL; } ptr

17 Speicherverwaltung in C int *intptr; intptr = (int*)malloc(sizeof(int)); *intptr = 4711; Zeiger deklarieren Speicher anfordern Wert setzen *intptr intptr x0050 free(intptr); int otherval = 5; intptr = &otherval; Speicher freigeben intptr umsetzen auf andere Speicheradresse *intptr intptr 5 0x0054 otherval &otherval 17

18 Malloc und free malloc und free werden benutzt, um Speicherplatz dynamisch zu allokieren/ deallokieren Dynamischer Speicherplatz (heap) ist ein freier Speicherplatzereich, in dem die Lebenszeit von Objekten vom Programm bestimmt wird. malloc allokiert so viel Speicher, wie angefragt, und gibt die Adresse zu dem bereich zurück Die Allokation mit malloc kann misslingen. Dann wird ein NULL-Pointer zurückgegeben Nach einer Speicherplatz-Allokation, sollte immer geprüft werden, ob diese gelungen ist. Dereferenzierung von Pointern vor malloc oder nach free führt zum Programmcrash. Speicherplatz ist nicht unbegrenzt! Alle Objekte, die mit malloc allokiert wurden, müssen mit free wieder frei gegeben warden, wenn sie nicht mehr gebraucht werden, andernfalls kann der Speicherplatz nicht wieder verwendet werden (memory leak) An free wird der Pointer, der malloc initialitisiert wurde, als Parameter übergeben 18

19 Stack vs. Heap Heap-Allokation int *intarray = (int*)malloc(3 * sizeof(int)); intarray[0] = 6837;... free(intarray); Stack-Allokation int intarray[3]; intarray[0] = 6837; 19

20 Pointer und Arrays Referenz auf mehrere zusammenhängende Speicherzellen (dynamisch allozierte Felder) #include <stdlib.h> int main() { int *ptr = (int*)malloc(3 * sizeof(int)); ptr[0] = 10; ptr[1] = 11; ptr[2] = 12 free(ptr); ptr return 0; }

21 Pointer und Arrays Felder sind in C intern implementiert als konstante Zeiger auf zusammenhängende Speicherblöcke X[0] 1 X[1] X[2] X[3] X[4] int main() { int j, x[5]; for (j = 0; j < 5; j++) x[j] = 0; x x+1 x+3 } int *ptr = x; * ptr = 1; // x[0] = 1 *(ptr+1) = 2; // x[1] = 2 *(ptr+3) = 5; // x[3] = 5 21

22 Pointer und Arrays Pointervariablen enthalten bzw. zeigen auf Adressen Ein Feldname repräsentiert Anfangsadresse des Feldes, ist somit ein unveränderlicher Pointer Wert einer Array-Variablen ist immer Adresse des ersten Array-Elements, also eine Adresskonstante Bei Feldern damit immer nur Call-by-Reference Übergabe Bsp.: int myarrayfunc(int arr[], int num) { } Pointerarithmetik Nur Addition bzw. Subtraktion mit Integer (z.b. p++) Ergebnis typabhängig: Größe eines Speicherobjekts des geg. Datentyps wird auf Adresse addiert n Elemente entsprechen n * sizeof(<datentyp>) Byte 22

23 Zeiger auf Zeiger void** Platzhalter für beliebigen Zeiger auf beliebigen Zeiger (beliebig wegen void) **ptr hingegen: Dereferenziert Zeiger, der auf einen Zeiger zeigt Und dereferenziert auch diesen zweiten Zeiger Findet also zur eigentlichen Information Link zu Pointer-Tutorial: Pointer notwendig für Eingaben: scanf("%d", &i); Pointer notwendig als Funktionsparameter (Call-by-Ref.) 23

24 ZEICHENKETTEN IN C 24

25 Zeichenketten Zeichenketten (bzw. Strings) sind in C char-arrays (sog. C-Strings ) C kennt keine speziellen Operationen auf Zeichenketten Es gibt nur Operationen auf einzelnen Zeichen (bzw. Arrays von Zeichen) Zeichenketten werden in der Regel mit Bibliotheksfunktionen bearbeitet: #include <string.h> 25

26 Strings Ein String in C ist ein Array von Characters char mystring[20]; Strings werden terminiert mit Character '\0' mystring[0] = 'H'; mystring[1] = 'i'; mystring[2] = '\0'; printf("%s", mystring); Was wird hier ausgegeben? 26

27 Zeichenketten Unterschied Pointer Array String: Pointer belegt nur eine einzige Speicheradresse Array oder String dagegen belegt viele Adressen Nur Bezeichner ist von Natur aus ein Zeiger Bei Vereinbarung wird für Array oder String Platz passender Länge reserviert Wie Arrays sind Zeichenketten (da Arrays von Zeichen) in C kein eigener Datentyp 27

28 Zeichenketten #include <stdio.h> int main() { char msg[10] = "Bonjour"; char *p; p = "Huhu"; // Array mit 10 Zeichen // Zeiger auf Zeichen // Konstanter String // Kurzform für msg2 = {'H','e','l','l','o','\0'} char msg2[] = "Hello"; // Compiler ermittelt Laenge printf("%s", "Bonjour"); } // Stringausgabe 28

29 Wie sieht der Speicher nachher aus? p = msg; p[0] = 'H'; p[1] = 'i'; p[2] = '\0'; msg (array) r 36 u 32 o 28 j 24 \0 n 20 o i 16 H B p 4 29

30 Zeichenketten Eine Zeichenkette steht immer auf gleichem Speicherplatz Angabe in Anführungszeichen oder Char-Feld char name[6] = {'H', 'o', 'r', 's', 't', '\0'}; /* '\0' end of string */ printf("%s", name); /* print until '\0' */ Sie kann verändert oder kopiert, aber in C nicht verschoben werden Jede Zeichenkette wird mit \0 abgeschlossen 30

31 Zeichenketten Bsp.: Einlesen einer Zeichenkette int tag, jahr; char monat[16]; scanf("%d %s %d", &tag, monat, &jahr); /* Feldname ist schon Referenz */ Dezember\0 31

32 Zeichenketten kopieren Wenn s und t Zeiger auf Zeichenketten sind: Kopieren einer Zeichenkette NICHT mit: s = t; Setzt nur Zeiger s auf Zeiger t, kopiert nur Zeiger Gilt analog für Felder allgemein 32

33 Zeichenketten kopieren Kopieren einer Zeichenkette z.b. von t nach s: void strcopy(char *s, char *t){ int i = 0; } /* durchlaeuft alle Zeichen */ while (t[i]!= '\0'){ s[i] = t[i]; i++; } /* '\0' noch nicht kopiert */ s[i] = t[i]; 33

34 Zeichenketten kopieren Kopieren einer Zeichenkette z.b. von t nach s: void strcopy(char *s, char *t) { int i = 0; } /* durchlaeuft alle Zeichen */ while((s[i] = t[i])!= '\0') /* Klammer wichtig */ i++; 34

35 Zeichenketten kopieren Kopieren einer Zeichenkette z.b. von t nach s: void strcopy(char *s, char *t) { while((*s = *t)!= '\0'){ /* weist zuerst zu, prueft dann */ s++; /* erhoeht spaeter */ t++; } } 35

36 Zeichenketten kopieren Kopieren einer Zeichenkette z.b. von t nach s: void strcopy(char *s, char *t) { while( (*s++ = *t++) ) ; /* weist zuerst zu, prueft dann, erhoeht nach Ende der Anweisung */ } [Kernighan] 36

37 Zeichenketten dynamisch Erstellen veränderlich langer Zeichenketten in C char* createnewstring(const char* cs) { /* Hilfszeiger, +1 wegen '\0' */ char *newstrg = (char*)malloc(strlen(cs)+1); } if (newstrg!= NULL){ strcpy(newstrg, cs); return newstrg; } return NULL; 37

38 Zeichenketten Bibliotheksfunktionen Zahlreiche Bibliotheksfunktionen in <string.h>, z.b.: char* strcpy(s,ct) char* strcat(s,ct) int strcmp(cs,ct) size_t strlen(cs) Kopiert Zeichenkette aus ct in s, liefert Zeiger auf s hängt Zeichenkette aus ct an s an, liefert Zeiger auf s Vergleicht Zeichenkette in cs mit Zeichenkette in ct, liefert < 0, wenn cs kleiner ist, 0, wenn beide gleich, sonst > 0 Liefert Länge von cs ohne \0 s hat den Typ char*, cs und ct den Typ const char* (werden nicht geändert) 38

39 Zeichenketten Beispiele für strcmp() bzw. strncmp() strcmp("a", "A") ist 0 strcmp("a", "B") ist -1 strcmp("b", "A") ist 1 Auf 4 erste Zeichen beschränkt: strncmp("fassade", "Fass", 4) ist 0 Achtung: strcmp("z", "a") liefert -1, da ASCII-Werte verglichen werden (genaue Rückgabewerte compilerabhängig) Stringlänge ermitteln mit strlen() char str[8] = "Hello"; Was gibt strlen(str) zurück? 5, 6 oder 8??? 39

40 Arrays mit Zeigern Ermöglicht bequeme Speicherung von C-Strings in Array Feld speichert nicht C-Strings selbst, sondern Zeiger auf Strings, die irgendwo anders im Speicher liegen Beispiel const char* suit[4] = { "Hearts", "Diamonds", "Clubs", "Spades" }; Jedes Element von suit zeigt auf einen char* (C-String) Array suit hat feste Größe (4 Zeiger mit je 4 Byte), aber Strings können hier beliebig groß sein Anmerkung: suit[i] i=0..3 kann wg. const nicht verändert werden! 40

41 Kommandozeile (Stringeingabe) Hauptprogramm kann Argumente haben int main(int argc, char *argv[]) argument count: Anzahl der Argumente des Programms bzw. Anzahl der Char-Zeiger in argv[] argument vector: Zeiger auf Vektor/Feld von Zeigern auf Zeichenfolgen, welche die Argumente enthalten Vgl. Java: public static void main( String[] args ) { } Programm kann so mit Anfangswerten versehen werden Zugriff mit z.b.: argv[i] Programmname steht in argv[0] 41

42 Kommandozeile (Stringeingabe) Sinn: Bei Aufruf von Kommandozeile aus kann Programm mit Parametern versorgt werden Ermöglicht so z.b. Batch-Verarbeitung 42

43 BITMANIPULATIONEN 43

44 Bitmanipulationen Logische Operationen zur Verarbeitung einzelner Bits in einem Speicherwort Zur Code-Beschleunigung in der Graphik (z.b. Flags in Bitfolgen), für En- und Decoding, Ansprechen / Steuern von Geräten usw. Beispiele: Motor ein/motor aus Pumpe ein/aus Heizung ein/aus Gerät eingeschaltet Drucker hat kein Papier Kopierer hat Papierstau 44

45 Bitmanipulationen Anzuwenden auf ganzzahlige Variable (z.b. unsigned int) Bitweises UND: a & b Bitweises ODER: a b Bitweises XOR: a ^ b (Exklusiv-ODER) a b a ^ b Bitweises Komplement: ~a (Einerkomplement) Linksshift: a << 2 Rechtsshift: a >> 2 Oft werden Variablen in hexadezimaler Form angegeben 45

46 Bitmanipulationen Beispiel: << Linksshift Verschiebt Daten um angeg. Anzahl von Bits nach links Bits, die links herausfallen, verschwinden Rechts wird mit Nullen aufgefüllt Bsp.: i <<= 4; // Identisch zu i *= 16; 46

47 Bitmanipulationen Schiebeoperationen >> >> 5 ergibt (rechts schieben) << (links schieben) (unsigned nutzen, Ergebnis abhängig von Vorzeichen) << 5 ergibt 47

48 Bitmanipulationen Die einzelnen Operationen (bitweise) & und & ergibt oder ergibt 48

49 Bitmanipulationen Die einzelnen Operationen (bitweise) ^ exklusiv-oder ^ ergibt ~ negieren ~ ergibt 49

50 Bitmanipulationen Anwendung für schnelle Operationen Feststellung, ob ein Wert gerade oder ungerade ist Vertauschen von Werten von Variablen Gerätesteuerung Computergraphik 50

51 Gerätesteuerung Lichter im Haus unsigned char licht; Schlafen1 Bad WC Gäste-WC Küche Schlafen2 Flur Wohnzimmer Wie können alle Lichter im Haus außer dem Flurlicht (soll Wert nicht verändern) mit einem Befehl ausgeschaltet werden? 51

52 Gerätesteuerung Lösung: C-Befehl: licht licht 52

53 Computergraphik Bit Block Transfers sind Operationen, bei der Pixelblock bitweise mit anderem kombiniert wird Z.B. XOR für sog. Rubberband oder Mauscursor Zweimal XOR stellt alten Wert wieder her Zeichenmodus Bsp.: Logische Verknüpfung mit XOR Source-Pixel: Destination-Pixel: Ergebnis:

54 STRUKTUREN IN C 54

55 Verbunddatentypen Mehrere, ggfs. verschiedene, Datentypen werden zu einer (Daten-) Struktur zusammengefasst Benutzername Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod Kontakte struct Messwerte { char name[42]; float hoehe; float breite; int index; } mess1, *mess2; Bild Bsp.: Profildaten in sozialem Netz Zugriff über Punkt-Operator, z.b.: mess1.hoehe Bei Pointern: mess2->hoehe 55

56 Aufbau von C-Structs Gruppen von Variablen Öffentliche Klassen ohne Methoden Können ineinander geschachtelt sein a) struct Name { /* Anweisungen */ } instanzname; b) struct Name { }; /* Anweisungen */ 56

57 Aufbau von C-Structs Definition einer Variablen mit Strukturtyp: struct Name instanzname; Definition eines neuen Struct-Datentyps: typedef struct Name NewType; Dient zur Verwaltung von Datensätzen Wird manchmal auch als Record bezeichnet 57

58 Beispiele für C-Structs Mögliche Datenstruktur für Typen Punkt und Rechteck: struct Point { /* Punkt auf Bildschirm */ int x; int y; }; struct Point p = { 47, 11 }; /* Init. */ struct Rectangle { /* Rechteck */ struct Point p1; struct Point p2; }; typedef struct Rectangle Rect; 58

59 Beispiele für C-Structs struct Birthday { int month, day, year; }; struct Person { char name[80]; float weight; float height; struct { /* embedded structure */ int month; int day; int year; } birth; }; 59

60 Beispiele für C-Structs struct Person you; Zugriff: you.birth.year = 1995; struct Person group[80]; strcpy(group[0].name, "Chantal"); group[0].height = 1.72f; group[0].birth.year = 1996;... Beachte: bei Pointern Pfeil- statt Punktnotation struct Birthday *d = malloc(sizeof(struct Birthday)); d->year = 1997; 60

61 Zuweisung von Strukturen Strukturen können Strukturen gleichen Typs zugewiesen, also einfach kopiert, werden: struct Point { /* Punkt auf Bildschirm */ int x; int y; } p1, p2;... p1.x = 47; p1.y = 11; p2 = p1; /* Werte werden kopiert */ Beide haben gleichen Inhalt, aber verschiedene Stellen im Speicher, anders als Klassen in Java! 61

62 Zusammenfassung Deklarieren eines Structs struct [optional name] { <type> field1;... } [instance list]; Beispiele: struct Foo { int field1; char field2; } foo, *foo_ptr; struct Foo foo2; struct List { int data; struct List *next; }; Zugriff auf Struct-Felder foo.field1; greift auffield1 der Instanz foo von struct Foo zu Pointer-Syntax und Structs * hat weniger Vorrang als. : *foo_ptr.field1; bedeutet *(foo_ptr.field1); Was vielleicht nicht kompiliert Zugriff auf ein Feld in einem Struct - Pointer: (*foo_ptr).field1; foo_ptr->field1; 62

63 Exkurs: Aufzählungsdatentyp Ein enum ist ein Aufzählungstyp mit begrenztem Wertebereich. Alle erlaubten Werte werden festgelegt. enum PrimaryColors { RED = 0, GREEN, BLUE } c; c = GREEN; Optional: Name des enum Per Default, erhält die erste Option den Wert 0 Jeder Option können beliebige Integerwerte zugewiesen werden Hintereinander liegende Optionen bekommen den Wert des Vorgängers plus 1 63

64 Exkurs: Union Eine Union erlaubt die Nutzung eines Speicherbereichs für unterschiedliche Felder union Argument { char charval; int intval; float floatval; }; Optional: Name der Union Eine Änderung von intval ändert floatval und charval! Wird für constrained-type containers benutzt Üblicherweise zusammen mit einem enum, das festlegt, welches Feld gültig ist 64

65 Exkurs: Speicherung von struct und union union-elemente teilen sich Speicherplatz Speichern der Elemente in union nicht nacheinander, sondern übereinander 65

66 Auswertungsreihenfolge /w/c/language/operator_pr ecedence 66

67 Lernziele Zeiger in C kennen und anwenden können Wissen, wie der Speicherplatz in C verwaltet wird Den Zusammenhang zwischen Arrays und Zeigern kennen und anwenden können Bitmanipulationen und ihre Anwendung kennen C-Strukturen (Records) kennen und anwenden können 67

68 FRAGEN? 68