Teil 6: Strukturen und Unionen Gliederung

Transkript

1 Teil 6: Strukturen und Unionen Gliederung Strukturen Typdefinitionen Unionen Dynamische Speicherverwaltung

2 Strukturen 6.2

3 Strukturen Ursprung in Pascal als Datentyp record, Verbunddatentyp Strukturtyp in C kann Komponenten (Variablen) verschiedener Typen enthalten: Personal- Nachname Vorname Straße Haus- Postleit- Wohnort Gehalt nummer nummer zahl int char[20] char[20] char[20] int int char[20] float Anwendung: Gruppierung logisch zusammenhängender Daten z. B. Datum, Adresse, Personendaten, geometrische Objekte,. Behandlung beim Lesen und Schreiben immer als als Einheit 6.3

4 Strukturtyp-Definition frei definierter, zusammengesetzter Datentyp feste Anzahl von Komponenten struct Name typ1 komponentenvariable_1; typ2 komponentenvariable_2;... typn komponentenvariable_n; }; der Typname ist struct Name 6.4

5 Strukturvariablen-Definition Variable eines Strukturtyps = aus Komponentenvariablen zusammengesetzte Variable Strukturvariable Komponentenvariable 1 Komponentenvariable 2... Komponentenvariable n Erstellung einer Variablen des Typs struct Name struct Name variable; 6.5

6 Beispiel-Definition struct Adresse char strasse[20]; int hausnummer; int postleitzahl; char stadt[20]; }; struct Student int matrikelnummer; char name[20]; char vorname[20]; struct Adresse wohnort; }; struct Student meyer, mueller; // 2 Studenten struct Student semester[50]; // Feld aus 50 Studenten 6.6

7 Übergabe an Funktionen call-by-value (wie bei elementaren Datentypen int, float, etc.) Initialisierungslisten struct Student student1 = 66202, "Meyer", "Herbert", "Schillerplatz", 20, 73730, "Esslingen" } }; 6.7

8 Zugriff auf Komponentenvariablen student1.matrikelnummer = ; struct Wort char s[20]; } struct Wort w1, w2; char c1[20], c2[20]; strcpy(c1, "Hallo"); strcpy(w1.s, "Hallo"); c2 = c1; /* FALSCH, ein Feld ist kein L-Value */ strcpy(c2, c1); /* RICHTIG */ w2 = w1; /* RICHTIG, eine Struktur ist ein L-Value */ 6.8

9 Zugriff auf Komponentenvariablen student1.matrikelnummer = ; strcpy (student1.name, "Meyer"); student1.wohnort.postleitzahl = 73733; strcpy (student1.wohnort.stadt, "Esslingen"); printf ("%6d %5d %s\n", student1.matrikelnummer, student1.wohnort.postleitzahl, student1.name); 6.9

10 Kombination von Typ- und Variablendefinition ohne Strukturname/Etikett (unüblich) struct float x; float y; } punkt1, punkt2, punkt3; mit Strukturname/Etikett (üblich) struct Koordinaten float x; float y; } punkt1, punkt2, punkt3; struct Koordinaten punkt4, punkt5, punkt6; 6.10

11 Struktur-Zuweisungen, Vergleich direkte Zuweisung möglich, alle Komponentenwerte der Variablen punkta werden den jeweiligen Komponenten der Variablen punkt3 zugewiesen struct Koordinaten punkta = 1.5, 3.0}, punktb; punktb = punkta; ABER: Prüfung auf Gleichheit if (punkta == punktb) ist nicht möglich! Bestimmung der Größe in Bytes einer Strukturvariablen: sizeof (struct Koordinaten) 6.11

12 Selektion über Zeiger Punktoperator. und Pfeiloperator -> struct Koordinaten float x; float y; }; struct Koordinaten punkta = 1.5, 3.0}, *ppunkt; ppunkt = &punkta; Wie greife ich auf Komponenten von punkta über den Zeiger ppunkt zu? Komponenten-Selektion über Zeiger auf 2 Arten möglich: (*ppunkt).x bzw. ppunkt->x (*ppunkt).x = 3; ppunkt->x = 3; 6.12

13 Zeiger und geschachtelte Strukturen Strukturvariablen als Komponenten struct Vektor struct Koordinaten *anfang; struct Koordinaten *ende; }; Zeiger vom Typ Vektor struct Vektor vec, *pvec; vec.anfang = &punkt2; vec.ende = &punkt3; pvec = &vec;... pvec->anfang->x bzw. 6.13

14 Strings in Strukturen String als Komponentenvariable struct Name char nachname[20]; char *vorname; }; struct Name person1 = "Maier", "Herbert"}; char nachname[20]; strukturintern, String gehört zur Strukturvariablen char *vorname; strukturextern, (in diesem Falle konstanter String) 6.14

15 Typdefinition mit typedef 6.15

16 Was ist typedef? Vergabe eines neuen Namens (Alias) neuername für einen schon bekannten oder soeben definierten Datentyp typedef bekanntertyp neuername; Beispiele: typedef unsigned long int UINT; UINT a; typedef float REAL; REAL b; 6.16

17 Anwendung spart Schreibarbeit Portierbarkeit von Programmen mit maschinenabhängigen Datentypen (maschinenabhängige Datentypen treten NUR in der typedef Zeile auf) Beispiel: Windows-API

18 Anwendung Beispiel: einheitlicher Long-Integer LINT typedef long long int LINT; // Anpassung auf LLP64-System typedef long int LINT; // Anpassung auf LP64-System 6.18

19 typedef und Strukturen struct Datum short int tag; char monat[10]; short int jahr; }; typedef struct short int tag; char monat[10]; short int jahr; } DATUM; struct Datum heute; DATUM heute; Empfohlene Variante 6.19

20 Unionen 6.20

21 Union-Definition Benutzung wie Struktur ABER: alle Komponenten (Alternativen) beginnen bei der selben Adresse speichert jeweils nur eine einzige Komponente (aus Reihe von Alternativen) Programmierer ggf. muss verfolgen, welcher Typ momentan in der Union gespeichert ist union Variant int intalternative; float floatalternative; }; 6.21

22 Zugriff auf Alternativen union Variant int intalternative; float floatalternative; }; int x; union Variant vario; Alternative schreiben / auslesen vario.floatalternative = 123.0; x = vario.intalternative; Zeiger auf Union union Variant *pvario = &vario; x = pvario->intalternative; 6.22

23 Beispiel: Prozessorregister struct WORDREGS unsigned int ax; unsigned int bx; unsigned int cx; unsigned int dx; }; struct BYTEREGS unsigned char al,ah; unsigned char bl,bh; unsigned char cl,ch; unsigned char dl,dh; }; union REGS struct WORDREGS w; struct BYTEREGS b; }; union REGS inregs; inregs.w.ax = 0x0815; /* BX Register auf Hex 0815 setzen */ inregs.b.ch = 0x1A; /* AH Register auf Hex 1A setzen */ 6.23

24 Dynamische Speicherverwaltung

25 Dynamische Speicherverwaltung Problem: Speicherbedarf ist während verschiedener Programmausführungen unterschiedlich Lösung: Variablen (insb. Arrays) maximal dimensionieren: char eingabetext[1000]; Nachteile? Variable Feldgröße in lokalen Arrays nutzen (ab C99) 6.26

26 Statische vs. dynamische Variablen statische Variable (inkl. lokal, global) int x; Verfügbarkeit und Ablage/Speichersegment je nach Speicherklasse (auto, register, static, extern) Speichersegmente Code globale Variable lokale Variable Daten Heap Stack 6.27

27 Statische vs. dynamische Variablen dynamische Variable hat keinen Bezeichner, keine Vereinbarung Anlegen erfolgt bei Bedarf auf dem Heap Zugriff durch Zeiger auf Bereich im Heap Code stat. Pointer- Variable Daten globale Variable Daten stat. Pointer- Variable Stack lokale Variable Heap Stack dyn. Variable Heap dyn. Variable 6.28

28 Dynamische Speicherverwaltung Problem: Speicherbedarf ist während verschiedener Programmausführungen unterschiedlich Lösung bisher: Variablen (insb. Arrays) maximal dimensionieren Nachteil: "verschenkter" Speicher 6.29

29 Dynamische Speicherverwaltung Problem: Speicherbedarf ist während verschiedener Programmausführungen unterschiedlich Lösung bisher: Variablen (insb. Arrays) maximal dimensionieren Nachteil: "verschenkter" Speicher Lösung neu: Speicherbedarf dynamisch, d.h. zur Programmlaufzeit festlegen stdlib.h bietet Funktionen zum Speicheranforderung und -freigabe: void* malloc(int Groesse); void* calloc(int AnzahlElemente, int ElementGroesse); void* realloc(void *memblock, int Groesse); void free(void *memblock); 6.30

30 Speicherreservierung mit malloc() #include <stdio.h> #include <stdlib.h> int main() int *pmem; pmem = malloc(sizeof (int)); if (p!= NULL) *pmem = 3; printf("pointer auf int-zahl mit Wert: %d\n", *pmem); free(pmem); } else printf("speicheranforderung fehlgeschlagen.\n"); } return 0; 6.31

31 Speicherreservierung mit realloc() I #include <stdio.h> #include <stdlib.h> int main() int *pmem; pmem = malloc(sizeof (int)); if (pmem == NULL) printf("speicheranforderung fehlgeschlagen.\n"); return -1; } *pmem = 3; printf("nach malloc():\n"); printf("pointer auf int-zahl mit Wert: %d\n", *pmem);

32 Speicherreservierung mit realloc() II... pmem = realloc ((void *)pmem, 2 * (sizeof(int))); if (pmem == NULL) printf ("Speicheranforderung fehlgeschlagen.\n"); return -1; } pmem[0] = 4; pmem[1] = 6; printf("nach realloc():\n"); printf("1. Element von pmem hat den Wert: %d\n", pmem[0]); printf("2. Element von pmem hat den Wert: %d\n", pmem[1]); free(pmem); } return 0; 6.33

33 Speicherreservierung für ein Feld #include <stdio.h> #include <stdlib.h> int main() int *parray = NULL; int i, anzahl = 0; printf "Geben Sie die Anzahl der Feld-Elemente ein: "); scanf("%d", &anzahl); parray = malloc(anzahl * sizeof(int)); if (parray == NULL) return -1; // Nutzung des reservierten Speicherbereichs for (i = 0; i < anzahl; i++) parray[i] = i * i; }... free(parray); return 0; 6.34

34 malloc& free: Typische Fehler Fehler Folge 1) kein Speicher mehr frei 2) Freigabe einer falschen Adresse u.u. Absturz 3) Freigabe bereits freigegeben Speichers u.u. Absturz 4) Freigabe eines regulären Feldes / einer regulären Variablen mit free() u.u. Absturz 5) Freigabe eines nicht-initialisierten Speichers u.u. Absturz 6) Zugriff auf ungültigen Speicher vor der Speicheranforderung u.u. Absturz 7) Zugriff auf bereits freigegebenen Speicher u.u. Absturz 8) Zugriff auf Speicher mit ungültigen Indizes u.u. Absturz 9) Verlust des Speichers durch Überschreiben des Zeigers "memory leak" 10) Verlust des Zeigers durch Rücksprung aus einer Funktion "memory leak" 11) Verlust des Zeigers bei Rückgabe (return-value verworfen) "memory leak" 6.35