Beispiel für eine rekursive Funktion

Transkript

1 Rekursive Funktionen Werden verwendet, wenn ein Problem in Teilprobleme aufgespalten werden kann, von denen eines sofort lösbar ist und die weiteren eine etwas vereinfachte Form des Originalproblems sind. Zum Beispiel läßt sich das Drucken einer Zahl auf das Drucken einer Ziffer und das Drucken einer (kleineren) Zahl aufspalten. Der rekursive Aufruf muß zuerst bearbeitet werden, dann kann die letzte Ziffer gedruckt werden. 1

2 Beispiel für eine rekursive Funktion #include <iostream> using namespace std; void DruckeZiffer(short); void DruckeZahl(long); voidmain() DruckeZahl( ); cout << endl; DruckeZahl(-33); cout << endl; } DruckeZahl(0); cout << endl; 2

3 void DruckeZiffer(short d) switch (d) case 0: cout << '0'; break; } case 1: cout << '1'; break; case 2: cout << '2'; break; case 3: cout << '3'; break; case 4: cout << '4'; break; case 5: cout << '5'; break; case 6: cout << '6'; break; case 7: cout << '7'; break; case 8: cout << '8'; break; case 9: cout << '9'; break; } void DruckeZahl (long n) // rekursive Funktion if ( n < 0 ) cout << '-'; DruckeZahl(-n); } else long quotient; short rest; quotient = n/10; rest = n % 10; if(quotient > 0) DruckeZahl(quotient); } DruckeZiffer(rest); } 3

4 Ausgabe: Press any key to continue 4

5 9. Zeiger und Strukturen 5

6 Motivation Ein Array ist ein benutzerdefinierter Datentyp. Er besteht aus - Elementen mit identischem Typ - diese sind hintereinander (lückenlos) abgespeichert - der Zugriff auf ein Element erfolgt über einen Index. Eine Struktur ist ein benutzerdefinierter Datentyp. Er besteht aus - Elementen mit möglicherweise unterschiedlichen Typen - Die Abspeicherung ist i. a. unbekannt (irrelevant) - der Zugriff auf ein Element erfolgt über den Punktoperator. 6

7 Motivation Beispiele: Datum Uhrzeit Hoersaal Klausurtermin Punkt -> tag/monat/jahr :3 ganze (positive) Zahlen -> stunde/minute: 2 ganze (positive) Zahlen: -> bezeichnung/kapazitaet : Text/positive ganze Zahl: -> Datum/Uhrzeit/Hoersaal/Vorlesung/Aufsicht -> Gleitkommazahlen (elektrisches) Bauteil ->? 7

8 Schlüsselwort 9.1 Definition und Deklaration struct Name typelement1 nameelement1; typelement2 nameelement2; typelementn nameelementn; }; Name der Struktur üblicherweise mit Großbuchstabe beginnend. Inhalte der Struktur: Elemente/Eigenschaften/ Attribute Semikolon am Ende 8

9 struct Datum unsigned int tag; unsigned int monat; unsigned int jahr; }; Beispiele struct Hoersaal string bezeichnung; unsigned int kapazitaet; }; struct Punkt double x; double y; double z; }; struct Uhrzeit unsigned int stunde; unsigned int minute; }; struct Klausurtermin Datum termin; Uhrzeit zeit; Hoersaal raum; string vorlesung; string aufsicht; }; struct Bauteil string bezeichnung; double widerstand; bool stromfliesst; }; 9

10 Deklaration Die Deklaration erfolgt wie bisher: Beispiel: Namederstruktur variable1,variable2, Datum d1;d2; //2 Variable Uhrzeit u; //1 Variable Hoersaal raeume[20]; //Array mit 20 Elementen vom Typ Hoersaal Klausurtermin *t; //Zeiger auf Klausurtermin 10

11 Dateien Die Definition muss immer ausserhalb einer Funktion erfolgen. Üblicherweise erfolgt sie in einer separaten Datei (Headerdatei). Die Definition wird dann mittels include dort eingefügt, wo sie benötigt wird. #include "Datum.h" #include "Uhrzeit.h" #include "Hoersaal.h" #include "Klausurtermin.h" #include <iostream> using namespace std; void main() } 11

12 9.2 Elementzugriff Der Zugriff auf die einzelnen Elemente eines Objekts erfolgt mittels des Punktoperators: namedesobjekts.namedeselements Beispiel: Uhrzeit u,v; u.minute=0; u.stunde=12; cin>>v.stunde; cin>>v.minute; if ( v.stunde > u.stunde ) 12

13 Zugriff über Zeiger Ist die Adresse eines Objekts in einer Zeigervariablen gespeichert erfolgt der Zugriff mittels des Verweisoperators * Beispiel: Uhrzeit u, *ptr=&u; (*ptr).minute=0; //entspricht u.minute=0; Achtung: Klammern sind hier unbedingt erforderlich wg. der Rangfolge *ptr.minute würde als *(ptr.minute) interpretiert, was Unsinn ist, es sei denn das Element wäre ein Zeiger. 13

14 Pfeiloperator Der Verweisoperator wird bei Zeigervariablen üblicherweise durch den Pfeiloperator ersetzt. Beispiel: Uhrzeit u, *ptr=&u; Statt (*ptr).minute kann man besser ptr->minute schreiben ptr->minute=0; //entspricht u.minute=0; Dies ist weniger fehleranfällig, da hier keine Klammern notwendig sind. 14

15 9.3 Mehrfachverwendung Strukturen können innerhalb eines Systems mehrfach eingesetzt werden. Beispiel: Klausurtermin und main verwenden Uhrzeit, Datum, Hoersaal Also müssen in den Dateien main.cpp und Klausurtermin.h jeweils die Direktiven #include "Uhrzeit.h" bzw. #include "Datum.h" #include "Hoersaal.h" enthalten sein: -> Mehrfachdefinition -> Fehlermeldung Dies lässt sich durch spezielle Direktiven verhindern 15

16 Mehrfaches Includieren Um Mehrfachdefinitionen durch mehrfaches Includieren zu verhindern, werden spezielle Präprozessor-Direktiven bei der Definition der Struktur verwendet: #ifndef _Strukturname_ // if not defined Strukturname (begrenzt durch 2* _) #define _Strukturname_ // definiere Strukturname...// hier ist die Definition #endif // Ende der Definition Diese Direktiven sollten generell verwendet werden. #ifndef _Datum_ #define _Datum_ struct Datum unsigned int tag; unsigned int monat; unsigned int jahr; }; #endif 16

17 9.4 Operationen mit Strukturen Der Zuweisungsoperator zwischen Variablen mit identischem Strukturtyp ist erlaubt: Beispiel: Datum d1,d2; d2=d1;//zuweisung ist erlaubt. Andere Operatoren sind nicht definiert und müssen ggf. selbst programmiert werden - als Operatorfunktion (später). if ( d1== d2 ) //Fehlermeldung if ( d1!= d2 ) //Fehlermeldung 17

18 Strukturen als Parameter Strukturen können wie die elementaren Datentypen als Parameter von Funktionen verwendet werden, also sowohl mittels Call by Value als auch mittels Call by Reference. void ausgabe(datum t) //Call by Value cout<<t.tag<<'.'<<t.monat<<'.'<<t.jahr; } void ausgabe(uhrzeit &u) //Call by Reference cout<<u.stunde<<':'<<u.minute; } 18

19 Strukturen als Funktionswert Strukturen können auch als Ergebnis einer Funktion auftreten. Uhrzeit nulluhr() Uhrzeit u; u.minute=0; u.stunde=0; return u; } //Aufruf Uhrzeit v; v=nulluhr(); //Zuweisungsoperator ist erlaubt 19

20 9.5 Äquivalenz Strukturen mit unterschiedlichen Namen sind stets verschieden. Dabei spielt es keine Rolle, wenn die Elemente identisch sind. struct TYP1 double x; } struct TYP2 double x; } double h=0.0; Typ1 u; Typ2 v; u=v; // Fehlermeldung u=h; // Fehlermeldung 20

21 9.6 Datenstrukturen Beispiele Liste/Tabelle Baum :00 Informatik1 NB1 Linus :00 Mathematik NB2 Fibonacci. Urgroßvater... Urgroßmutter Großvater-V Großmutter-V Großvater-M Großmutter-M Graph/Netzwerk Vater Mutter Dieburg Münster Klein Umstadt Person Groß Zimmern Gross-Umstadt Raibach Array String Ein Neger mit Gazelle zagt im Regen nie 21

22 Datenstrukturen bestehen aus Objekten, Datenstrukturen die in einer speziellen Art und Weise zueinander in Beziehung stehen mit denen festgelegte Verarbeitungen durchgeführt werden können Sie sind primär durch die Organisation bzw. die Beziehung der Objekte zueinander und die zugehörigen Zugriffstechniken beschrieben und nicht durch den gespeicherten Inhalt 22

23 Sequenzielle Strukturen Die einfachsten Strukturen sind die sequenzielle Strukturen. Dabei sind die einzelnen Objekte sequenziell hintereinander angeordnet. Dies bedeutet jedoch nicht zwangsläufig, dass sie auch hintereinander abgespeichert sind. Bisherige Beispiele: Arrays Strings Bei verketteten Strukturen wird dagegen auf die sequentielle Abspeicherung wie bei den Arrays verzichtet. Stattdessen erhält man ausgehend von einem Objekt ein nächstes Objekt durch die Angabe von dessen Adresse. 23

24 9.7 Einfach verkettete Listen Es wird ein spezieller Zeiger für das erste Objekt benötigt Zeigervariable mit der Adresse des nächsten Objekts Erstes Objekt next next First... Zweites Objekt next Letztes Objekt NULL 24

25 Einfach verkettete Listen/Definition Eine Liste lässt sich als Struktur implementieren. Das einzige Element ist die Zeigervariable auf das erste Objekt der Liste Allgemein struct Liste Elementtyp* first; } Beispiel struct Hoersaalliste Hoersaal* first; } Hoersaalliste a; a.first = 0; //Leere Liste 25

26 Listenobjekte Ein Objekt lässt sich als Struktur implementieren, wobei ein Element next erforderlich ist, welches die Adresse des nächsten Listenobjekts enthält. Variante 1: Alle Elemente inkl. Zeiger sind einzeln aufgeführt struct Listenobjekt int Listenobjekt* next; }; struct HSE string bezeichnung; unsigned int kapazitaet; HSE* next; }; Variante 2: Zeiger auf Daten/next struct Listenobjekt Daten *inhalt; Listenobjekt* next; }; struct HSE Hoersaal *ptr_saal; HSE* next; }; Damit spielen die Daten keine Rolle mehr, da sie über einen Zeiger angesprochen werden. Alle Listen sind somit "gleich"; 26

27 Prinzipielle Aufgaben Neues (Listen-)Objekt erzeugen Erstellen (Aufbau) der Datenstruktur Listenobjekte einfügen Einfügen am Anfang Einfügen am Ende Einfügen gemäß einer gewünschten Sortierung Sonderfall: Einfügen in eine leere Struktur Verändern der Datenstruktur Listenobjekte einfügen (wie oben) Listenobjekte löschen Listenobjekt ändern Aktionen mit der Datenstruktur alle Listenobjekte anzeigen ein Listenobjekte suchen die Anzahl der Listenobjekte ermitteln. 27

28 Erzeugung eines Listenobjekts Ein Listenobjekt lässt sich mittels new erzeugen, zweckmäßigerweise in einer Funktion, die als Ergebnis die Adresse des neuen Elements liefert Listenobjekt* neueslistenobjekt(parameter1, ) Listenobjekt *neu = new Listenobjekt; neu->element1= parameter1; return neu; } Die erforderlichen Daten werden als Parameter übergeben HSE* neueshse(string pb, unsigned int pk) HSE *neu = new HSE; neu->bezeichnung = pb; neu->kapazitaet = pk; neu->next = 0; return neu; } 28

29 Einfügen am Anfang Ausgangssituation: first zeigt auf das erste Element/first kann NULL sein a) Einzufügendes Objekt Listelement a; a.next = first; first = &a; b) Einzufügendes Objekt Adresse gespeichert in Listelement *ptr. Dies ist etwa dann der Fall, wenn das Objekt mittels new erzeugt wurde. ptr->next = first; first = ptr; Testfälle: leere Liste nicht leere Liste 29

30 Aktionen mit verketteten Listen Anwendungsbeispiele: alle Algorithmen, die es auch für Arrays gibt Ausnahme: sortieren/mischen ist unüblich Der prinzipielle Ablauf ist stets derselbe: Beginnend bei dem ersten Objekt werden der Reihe nach alle anderen Objekte aufgesucht, bis kein Objekt mehr vorhanden ist. Bei Arrays lässt sich dies mit einer konventionellen for-schleife erreichen. Hier muss dies mittels Zeigern realisiert werden. AktuellesObjekt = erstesobjekt (= first) Solange AktuellesObjekt vorhanden (aktuell ist nicht NULL) Aktion mit AktuellesObjekt durchführen AktuellesObjekt = nächstesobjekt nach aktuellemobjekt (= AktuellesObjekt-> next) 30

31 Aktionen mit verketteten Listen Scrollen mit Aktion Vorlauf:Initialisierungen/Anfangsaktion Erstes Objekt wählen Solange Objekt vorhanden Objekt bearbeiten (Aktion) nächstes Objekt wählen Nachlauf: Abschlussaktion Beispiel Kopfzeile ausgeben, Zähler, Summationsvariable 0 setzen aktuellesobjekt=first aktuellesobjekt nicht NULL Aktion aktuellesobjekt=aktuellesobjekt->next Beispiel: Fußzeile ausgeben, Durchschnitt berechnen neue Seite 31

32 Prinzipieller Testplan Fall Beschreibung Daten Ergebnis 1 Leere Liste / 2 Liste mit 1 Element obj1 3 Liste mit 2 Elementen obj1,obj2 4 Liste mit 3 Elementen obj1,obj2,obj3 32

33 Beispiel: Anzeigen void anzeigen(hse* start) void ausgabe(hse*); HSE* aktuell=start; cout<<"hoersaaluebersicht"<<endl; while (aktuell!= 0) ausgabe(aktuell); aktuell=aktuell->next; } } Startelement als Parameter Ausgabefunktion für ein Listenelement Auch als void ausgabe(hse a) void ausgabe(hse &a) möglich. void ausgabe(hse* ptr) cout<<"raum "<<ptr->bezeichnung; cout<<" "<<ptr->kapazitaet<<" Plaetze"<endl; } 33

34 Beispielprogramm #include "HSE.h" #include <iostream> #include <string> using namespace std; void main() void ausgabe(hse*); void anzeigen(hse*); HSE* neueshse(string,unsigned int); HSE* first=null; for ( int i=0;i<3;i++) //Liste erstellen cout<<" Beschreibung / Kapazitaet "; string pb; unsigned int pk; cin>>pb>>pk; HSE* ptr=neueshse(pb,pk);//neues Objekt ptr->next=first; //einfügen am Anfang first=ptr; } anzeigen(first); } 34

35 Aktion: Zählen int zaehlen(hse* start) HSE* aktuell=start; int z=0; while (aktuell!=null) z++; aktuell=aktuell->next; } return z; } 35

36 Testplan Fall Beschreibung Daten Ergebnis 1 Leere Liste / 0 2 Liste mit 1 Element obj1 1 3 Liste mit 2 Elementen obj1,obj2 2 4 Liste mit 3 Elementen obj1,obj2,obj3 3 36

37 Aktion: Suchen HSE* suche(hse* start,string pb) HSE* aktuell=start; while (aktuell!=null) if ( aktuell->bezeichnung == pb return aktuell; aktuell=aktuell->next; } return NULL; } 37

38 Testplan Der Testplan ist in seiner Struktur identisch zum Testplan für Arrays. Der Plan wird aus Anwendersicht (Blackboxtest) erstellt. Daher ist es unerheblich, ob die Struktur als Array oder als verkettete Liste implementiert wird. Daher ist jeder Testplan abhängig von den Merkmalen Anzahl der Elemente positives/negatives Ergebnis Würde man sich bei den Testfällen vom Programmcode inkl. Implementierung leiten lassen gäbe dies möglicherweise eine andere Struktur des Testplans (Whiteboxtest). 38

39 Aktion: letztes Listenobjekt bestimmen HSE* suche(hse* start) HSE* aktuell=start; if ( aktuell = =0 )//Leere Liste return NULL; while (aktuell->next!= 0)//nicht letztes Objekt aktuell=aktuell->next; return aktuell; } 39

40 Testplan Fall Beschreibung Daten Ergebnis 1 Leere Liste / NULL 2 Liste mit 1 Objekt obj1 &obj1 3 Liste mit 2 Objekten obj1,obj2 &obj2 4 Liste mit 3 Objekten obj1,obj2,obj3 &obj3 40

41 Aktion: Löschen Aufgabenstellung: Es soll ein Objekt gelöscht werden. 1. Schritt: Vorgaenger + Objekt suchen -> Adressen gefunden 2. Schritt Objekt aus Liste entfernen 3. Verwendung des gelöschten Objekts klären next suchwert kopieren next next vorgaenger aktuell Befehl: vorgaenger->next =aktuell->next Sonderfall: wenn suchwert das erste Objekt ist. In diesem Fall ändert sich first und nicht voegaenger 41

42 Aktion: Löschen loeschen(start,pb) vorgaenger=null aktuell=start aktuell!=null ja aktuell->bezeichnung = pb nein ja aktuell=start nein start= aktuell->next vorgaenger->next= aktuell->next vorgaenger=aktuell aktuell=aktuell->next return 42

43 Aktion: Löschen void loeschen(hse* &start,string pb) HSE* aktuell=start,*vorgaenger=null; while (aktuell!=null ) if ( aktuell->bezeichnung==pb ) //gefunden if ( aktuell==start )//erstes Objekt start=aktuell->next; else vorgaenger->next=aktuell->next; return; } else //nicht gefunden vorgaenger=aktuell; aktuell=aktuell->next; } } 43

44 Testplan Wie suchen 44

45 Aktion: Löschen Vergleich mit Arrays Vorteil kein Umspeichern Nachteil zusätzlicher Speicherplatz für Zeiger Offene Frage Was geschieht mit dem gelöschten Objekt? Falls mit new erzeugt-> mit delete entfernen Ansonsten? 45

46 Aktion: Einfügen Ein Objekt soll in eine sortierte verkettete Liste eingefügt werden. Die Adresse ist in neu gespeichert. stelle neu < suchwert next suchwert next > suchwert next Aufgabe : man muss die erste Stelle finden, dessen Nachfolger einen größeren Suchwert (z.b. Artikelnummer) hat als das neue Objekt Sonderfälle : leere Liste, wenn neu das erste oder das letzte Objekt wird. 46

47 Aktion: Einfügen stelle neu < suchwert next suchwert next > suchwert next Befehlsfolge neu->next = stelle->next; stelle->next=neu Sonderfälle: einfügen am Anfang bzw. Ende 47

48 Aktion: Einfügen Einfügen Sortiert ja Liste leer Stelle finden nein In leere Liste einfügen Stelle=Anfang ja nein Stelle=Ende am Anfang ja nein einfügen Am Ende einfügen in der Mitte einfügen Programmcode: Übung 48

49 Testplan Einzufügendes Objekt: neu Fall Beschreibung Daten Ergebnis 1 Leere Liste / neu 2 Liste mit 2 Objekten obj1,obj2 2.1 vorne einfügen neu,obj1,obj2 2.2 in der Mitte einfügen obj1,neu,obj2 2.3 hinten einfügen obj1,obj2,neu 49

50 Aktion: Einfügeposition finden HSE* position(hse*start,string pb) HSE* aktuell=start, *vorgaenger=0; while (aktuell!=null ) if ( aktuell->bezeichnung>=pb ) return vorgaenger;//gefunden else //nicht gefunden vorgaenger=aktuell; aktuell=aktuell->next; } return vorgaenger;//letztes falls nicht gefunden } Es soll das Objekt gesucht werden, nach dem das neue Objekt eingefügt werden soll. Kriterium: sortiert nach bezeichnung Vorgehensweise: suche das erste Objekt, welches eine "größere" bezeichnung hat. Davor kommmt das neue Objekt Testplan: wie einfügen 50

51 9.8 Doppelt verkettete Listen Neben der Adresse des nachfolgenden Objekts ist auch noch die Adresse des vorhergehenden Objekts gespeichert. first last left right left right left right 51

52 Doppelt verkettete Listen Die Algorithmen sind analog den Algorithmen der einfachen Verkettung. Vorteil: Das Ende der Struktur ist sofort zugreifbar. Nachteil: zusätzlicher Zeiger erhöhter Aufwand bei den Agorithmen 52

53 9.9 Weitere sequenzielle Strukturen Es gibt spezielle sequenzielle Strukturen, bei denen für die Operationen Einfügen und Löschen spezielle Randbedingungen gelten: Diese Operationen sind dann nur am Anfang (erstes Objekt) bzw. am Ende (letztes Objekt) erlaubt. 53

54 Stack (Keller, Stapel, Kellerstapel) Ein Stack ist eine sequentielle Struktur von Objekten, bei der die Operationen Einfügen und Löschen nur an einem Ende möglich sind. Prinzip: LIFO (last in first out) Einfügen Löschen 54

55 Operationen auf einem Stack Ein Stack lässt sich mittels einer verketteten Liste oder auch einem Array implementieren. Wichtig dabei ist, dass ein spezieller Satz an Funktionen bereitgestellt wird: push pop top/peek empty ein Objekt einfügen das zuletzt eingefügte Objekt löschen das zuletzt eingefügte Objekt liefern prüfen ob der Stack leer ist 55

56 Anwendungen Anwendungsbeispiele Browsen im Internet Aufruf von Menuestrukturen Aufruf/Return von Funktionen in Programmen (Rücksprungadresse im Stack merken) Analyse von Klammerstrukturen ( : push ) : pop 56

57 Queue (Schlange, Warteschlange) Eine Warteschlange ist eine sequentielle Struktur von Objekten gleichen Typs, bei der die Operation Einfügen nur an dem einen Ende, die Operation Löschen nur an dem anderen Ende möglich ist. Prinzip: FIFO (first in first out) Einfügen Löschen 57

58 Operationen auf einer Queue Wie Stack 58

59 Anwendungen Anwendungsbeispiele Abarbeitung von Maus- und Tastaturereignissen Management von Druckaufträgen (Spooling) Bestellsysteme 59

60 9.10 Bäume Beispiel Stammbaum Urgroßvater... Urgroßmutter Großvater-V Großmutter-V Großvater-M Großmutter-M Vater Mutter Person 60

61 Prinzip Definition von Bäumen: Es gibt genau ein Objekt ohne Vorgänger -> Wurzel Verschiedene Objekte haben keine gemeinsamen Nachfolger oder Jedes Objekt hat genau einen Vorgänger (außer die Wurzel) Hat jedes Objekt genau 2 Nachfolger (inkl. NULL) so spricht man von einem Binären Baum Anstelle von next gibt es hier dann einen linken Nachfolger (left) und einen rechten Nachfolger (right) 61

62 Anwendungen Anwendungsbeispiele sitemap einer Internetanwendung Verzeichnisbaum/-struktur Arithmetische Ausdrücke + / * a + d - b c e f 62

63 Algorithmen Die Algorithmen für Einfügen und Löschen sind analog zur Verkettung. Die Algorithmen für Anzeigen und Suchen werden in der Regel rekursiv programmiert. void anzeigebaum(be* wurzel) wurzel->anzeigen();//anzeige eines Objekts if (wurzel->left!=null) anzeigebaum(wurzel->left); if (wurzel->right!=null) anzeigebaum(wurzel->right); } 63

64 Algorithmen: Suche Der große Vorteil von Bäumen liegt in der schnellen Suche. Der Aufwand ist vergleichbar dem bei der binären Suche log 2 (anzahl). Der Algorithmus ist analog zur binären Suche. BE* suchebaum(be* wurzel, typ key) if ( wurzel==null ) return NULL; else if ( wurzel->xxx==key ) return wurzel;//gefunden else if ( key<wurzel->xxx )//nicht gefunden return suchebaum(wurzel->left); else return suchebaum(wurzel->right); } } Datentyp zur Suche Element zur Suche 64

65 Strukturen und Verbunde (Unions) Selten gibt es in Programmen Felder, die für sich alleine stehen, meist gehören Gruppen von Datenwerten zusammen. Beispiel: Gruppe von Kindern mit Gewicht, Geschlecht, Alter und Größe: const int MAXKINDER = 1000; double groesse[maxkinder]; double gewicht[maxkinder]; int alter_jahre[maxkinder]; int alter_monate[maxkinder]; char geschlecht[maxkinder]; Jetzt sind die Daten eines einzelnen Kindes nur über den gleichen Index als zusammengehörig erkennbar viele Fehlermöglichkeiten! In C++ kann eine Zusammengehörigkeit durch Strukturen gekennzeichnet werden. Wie die Felder, sind auch die Strukturen und Verbunde abgeleitete Datentypen, sie werden aus den einfachen Grundtypen zusammengesetzt. 65

66 Strukturen und Verbunde (Unions) Strukturen werden mit dem Schlüsselwort struct deklariert, diesen folgt der Name der Struktur und dann in geschweiften Klammern die Liste der Variablen, aus denen die Struktur besteht. Beispiel: struct Kind double groesse; double gewicht; int alter_jahre; int alter_monate; char geschlecht; }; Mit dieser Deklaration wird der Typ Kind bekanntgemacht. Die Struktur besteht aus den double-variablen groesse und gewicht, den int-variablen alter_jahre und alter_monate und der char-variablen geschlecht. Die Gesamtlänge einer Variablen vom Typ kind ist 2 * 8 Bytes (double) + 2 * 4 Bytes (int) + 1 Byte (char) =

67 Strukturen und Verbunde (Unions) Definition von Variablen vom Typ Kind: Kind Berta; Kind Hugo; Kind testgruppe [MAXKINDER]; Vorbesetzung: Kind beispiel = 125.0, 32.5, 13, 2, w }; Zugriff auf einzelne Elemente der Struktur : Berta.gewicht = 37.5; if (Hugo.groesse > g_grenze)... Auch die komplette Struktur kann verwendet werden: z.b. Kind groesstes; groesstes.groesse = 0; for ( int i=0; i < AnzKinder ; i++) if ( testgruppe[i].groesse > groesstes.groesse ) groesstes = testgruppe[i]; 67

68 Strukturen und Verbunde (Unions) Verbunde ( Unions) sind den Strukturen sehr ähnlich, allerdings liegen die einzelnen Komponenten nicht hintereinander im Speicher, sondern sozusagen übereinander. Alle Komponenten beginnen an der gleichen Stelle. Verbunde werden mit dem Schlüsselwort union deklariert. z.b. union test long zahl; char zeichen [4]; }; Die Länge einer Union ist gleich der Länge der längsten Komponente. Im Beispiel 4 Bytes. 68

69 Anwendung: #include <iostream> #include <string> using namespace std; int main (void) union test long zahl; char zeichen [4]; }; test variable; variable.zahl = ; cout << endl << variable.zeichen<< endl; cout << endl << variable.zahl<< endl; strcpy ( variable.zeichen,"oha"); cout << endl << variable.zeichen<< endl; cout << endl << variable.zahl<< endl; return 0; } 69

70 Ausgabe: % Oha ( Wer zuletzt schreibt hat gewonnen! ) Verbunde werden daher nur selten verwendet. 70