Übersicht 9.1 Strukturen (Verwendung) 9.2 Strukturen (Typdeklaration) 9.3 Strukturen (Variablendeklaration) 9.4 Felder aus Strukturen 9.5 Zugriff auf Strukturkomponenten 9.6 Zugriff auf Strukturkomponenten (Beispiel) 9.7 Zuweisung kompletter Strukturen 9.8 Strukturen als Funktionsparameter (by value) 9.9 Strukturen als Funktionsparameter (by value), Zugriff auf Komponenten 9.10 Strukturen als Funktionskomponenten (by reference) 9.11 Der Strukturoperator 9.12 Strukturen als Funktionsparameter (by reference) Beispiel 1 9.13 Strukturen als Funktionsparameter (by reference) Beispiel 2-1 9.14 Strukturen als Funktionsparameter (by reference) Beispiel 2-2 9.15 Strukturen als Funktionsparameter (by reference) Beispiel 3-1 9.16 Strukturen als Funktionsparameter (by reference) Beispiel 3-2 9.17 Enumerationen (Aufzählungstyp) 9.18 Unions Prof. Martin Trauth Folie 1 / 19
9.1 Strukturen (Verwendung) Die Dinge des täglichen Lebens haben eine Vielzahl von Eigenschaften. Ein Mensch beispielsweise hat (meistens) einen Namen, ein Körpergewicht, eine Körpergröße und in den meisten Staaten auch eine Ausweisnummer. Waren haben Verkaufspreise, ein Gewicht, eine Bezeichnung, einen Lieferanten (und der hat auch wieder einen Namen, eine Adresse usw.) und noch viele andere Eigenschaften. Einfache Datentypen, wie char, int, float oder double, eignen sich nur zur Beschreibung einer einzigen Eigenschaft. Ein Gewicht kann man gut in einer float-variablen speichern, einen Namen in einem char-feld. Aber man hätte gerne eine Möglichkeit alle Eigenschaften eines Dings, mit denen man in einem Programm arbeiten möchte, in einem einzigen Datentyp zusammen zu fassen. Dazu benötigt man einen so genannten benutzerdefinierten Datentyp: eine Struktur. Strukturen setzen sich aus Komponenten zusammen. Das können einfache Datentypen sein oder andere Strukturen. Prof. Martin Trauth Folie 2 / 19
9.2 Strukturen (Typdeklaration) Syntax einer Strukturdeklaration: struct <Name der Struktur> { <Liste der Strukturvariablen, durch Semikolon getrennt> ; struct student { ; int matrikelnr; char vorname [30]; char nachnahme [30]; struct adresse heimatadresse; struct adresse semesteradresse; int immatrikulationsjahr; Die Struktur struct adresse wird in der Struktur struct student als Variablentyp verwendet. struct adresse { ; char strasse [30]; int hausnr; char wohnort [30]; In blau sind Typenbezeichnungen markiert. Namen von Variablen bzw. Komponenten sind schwarz geschrieben. Die Strukturkomponenten (Strukturvariable) werden nur in der Strukturdeklaration deklariert, nirgends sonst. Wenn man Strukturen als Komponenten in anderen Strukturen verwendet müssen sie vorher im Programm deklariert werden. In unserem Beispiel müsste struct adresse vor struct student deklariert werden. Meist werden Strukturen (ähnlich wie externe Variable) vor allen Funktionen und außerhalb davon deklariert. Sie gelten dann in allen Funktionen. Prof. Martin Trauth Folie 3 / 19
9.3 Strukturen (Variablendeklaration) Durch die Deklaration eines Strukturtyps ist noch keine Variable dieses Typs deklariert! In unserem Beispiel ist struct student ein Datentyp wie int aber es gibt noch keine Variable dieses Typs. Das macht man durch eine Typdeklaration (wie bei einfachen Typen auch). Syntax: < Typ > < Liste der Variablennamen >; struct adresse meine_adresse, deine_adresse; Oder man macht Typ- und Variablendeklaration gleich zusammen: struct adresse { char strasse [30]; int hausnr; char wohnort [30]; meine_adresse; Variablenname Bei dieser Art der Variablendeklaration kann man den Strukturnamen auch ganz weglassen! Wird oft aus Bequemlichkeit gemacht, hat aber einen Nachteil: man kann die Strukturdeklaration dann für keine weiteren Variablendeklarationen verwenden und nicht als Typbezeichnung in Funktionsparametern. Prof. Martin Trauth Folie 4 / 19
9.4 Felder aus Strukturen Meist macht man sich nicht die Mühe einen Strukturtyp zu deklarieren, wenn man nur eine Variable davon haben möchte. Viel öfter werden Struktur-Felder verwendet. Das funktioniert genau so wie bei den einfachen Datentypen. Man schreibt in eckigen Klammern hinter dem Variablennamen die Feldgröße. struct student fh-student[20000]; Damit könnte man nun die Daten von 20000 Studenten abspeichern. In der Struktur struct student sind auch die Adressen der Studenten deklariert. Man muss aber kein Feld mit 20000 Adressen anlegen, denn die Variablen semesteradresse und heimatadresse sind Bestandteile der Struktur struct student und werden daher automatisch verzwanzigtausendfacht. Prof. Martin Trauth Folie 5 / 198
9.5 Zugriff auf Strukturkomponenten Beim Zugriff auf Strukturkomponenten schreibt man den Strukturnamen, dann einen Punkt ( Punktoperator genannt) und dann den Komponentennamen. meine_adresse.hausnr = 10; Sind es verschachtelte Strukturen, dann schreibt man eine hierarchische Folge von Komponentennamen, durch Punkte getrennt. fh_student[387].semesteradresse.hausnummer = 95; An dem Beispiel ist auch zu erkennen, dass man Strukturfelder im Grunde genau so indiziert wie Felder einfacher Datentypen: Index als Ganzzahl in die eckigen Klammer nach dem Namen der Strukturvariablen schreiben. Falls als Strukturkomponenten wiederum Felder verwendet wurden, kann man auf deren einzelne Elemente auch wieder durch Indizierung zugreifen. In dem Fall stehen die eckigen Klammern mit dem Index hinter dem Namen der betreffenden Komponente. c = fh_student[5].heimatadresse.wohnort[0]; In der Variablen c (die natürlich als char deklariert sein muss) steht dann das erste Zeichen des char-felds wohnort. Prof. Martin Trauth Folie 6 / 19
9.6 Zugriff auf Strukturkomponenten (Programmbeispiel) #include <stdio.h> #include <string.h> main() { int i; struct waren { char bezeichnung[40]; double preis; lagerware[500] ; strcpy(lagerware[0].bezeichnung, "Kaffetasse blau"); lagerware[0].preis = 17.50; strcpy(lagerware[1].bezeichnung, "Untertasse blau"); lagerware[1].preis = 3.55; for (i = 0; i <= 1; i++) { printf("ware: %s\n", lagerware[i].bezeichnung); printf("preis: %.2lf Euro\n\n", lagerware[i].preis); Ausgabe: Verwendung von strcpy(), weil keine Zuweisung von Zeichenketten durch = möglich! Zugriff über den Feldindex Prof. Martin Trauth Folie 7 / 19
9.7 Initialisierung von Strukturkomponenten, Zuweisung kompletter Strukturen Man kann natürlich, wie im vorangegangenen Beispiel gezeigt, jede einzelne Strukturkomponente durch Zuweisungen mit Werten versehen. Will man sie gleich bei der Deklaration der Struktur initialisieren, dann kann man das mit einer Liste tun. struct adresse { char strasse [30]; int hausnr; char wohnort [30]; meine_adresse = { auf dem Berg, 3, Lummerland ; Das Verfahren wird selten angewendet und ist nur für einfache Struktur-Variable (keine Felder) brauchbar. Wesentlich wichtiger ist, dass man Strukturvariable direkt zuweisen kann und zwar jederzeit im Programm und auch dann wenn Datenfelder als Komponenten vorhanden sind! Dieses Beispiel wäre also gültig: deine_adresse = meine_adresse; Die Werte aller Struktur-Komponenten (falls vorhanden), werden von meine_adresse in deine_adresse kopiert. Prof. Martin Trauth Folie 8 / 19
9.8 Strukturen als Funktionsparameter (by value) Wie Variable einfacher Typen kann man auch Strukturen als Funktionsparameter verwenden. Und natürlich können Strukturkomponenten wie Variable des jeweiligen Typs übergeben werden. Die Syntax bei Übergabe kompletter Strukturen ist auch die gleiche wie bei einfachen Typen (sowohl in Funktionskopf als auch bei Prototypen). Beispiele für Übergabe von Strukturkomponenten: int myfunction (double wert1) Funktionskopf für die Übergabe eines double-parameterwerts int myfunction (double); Prototyp für diese Funktion i1 = myfunction (messung.akt_wert); Aufruf dieser Funktion. Der double-wert stammt von einer double Komponente wert der Strukturvariablen messung Beispiele für die Übergabe ganzer Strukturen (es werden die Werte der Strukturkomponten übergeben): void show_all(struct adresse para_adresse) Funktionskopf für die Übergabe einer Struktur. Wieder ist struct adresse der Typ! void show_all(struct adresse); show_all(meine_adresse); Der Prototyp. Die Typangabe ist notwendig, der Variablenname nicht. Der Funktionsaufruf erfolgt ganz einfach mit dem Namen der Strukturvariablen in der aufrufenden Funktion. Alle Werte der Strukturkomponenten von meine_adresse werden dabei in die der Struktur para_adresse kopiert. Prof. Martin Trauth Folie 9 / 19
9.9 Strukturen als Funktionsparameter (by value), Zugriff auf Komponenten Die aufgerufene Funktion kann nun auf alle Komponenten der Parameter-Struktur zugreifen. Beispiel (wir gehen davon aus, dass es eine Programmzeile in der Funktion show_all ist): printf( Zuhause in: %s, para_adresse.wohnort); Aber Achtung: es handelte sich um eine Parameterübergabe by value, d.h. es wurden nur die Werte der Strukturkomponenten an die aufgerufene Funktion übergeben. Nun stehen sie in einer Strukturvariablen (im Beispiel ist es para_adresse), die nur in der aufgerufenen Funktion bekannt ist. Werden die Werte ihrer Komponenten geändert, dann merkt die aufrufende Funktion nichts davon. In diesem Beispiel bleiben die Werte der Strukturkomponenten von meine_adresse unverändert (wir gehen wieder davon aus, dass es eine Programmzeile in der Funktion show_all ist): strcpy(para_adresse.wohnort, Neustadt ) ; Die Komponente wohnort wird nur in der Struktur-Variablen para_adresse geändert. Das hätte (bei Verwendung dieser Komponente) Auswirkungen in der Funktion show_all( ), aber nicht in der aufrufenden Funktion (z.b. main( ) ). Prof. Martin Trauth Folie 10 / 19
9.10 Strukturen als Funktionsparameter (by reference) Will man Strukturen der aufrufenden Funktion in der aufgerufenen Funktion verändern, dann erreicht man das (wie bei einfachen Datentypen) dadurch, dass man nicht die Werte der Strukturkomponenten als Parameter übergibt, sondern die Adresse der Struktur. Die Syntax ist auch fast die gleiche wie beim call by reference einfacher Datentypen. Man verwendet also Pointervariable als Funktionsparameter. Aber der Zieltyp dieses Pointers ist eine Struktur. void func10(struct adresse *padresse) Funktionskopf für die Übergabe einer Struktur by reference. struct adresse ist der Zieltyp des Pointers padresse. void func10(struct adresse *); Der Prototyp. func10(&meine_adresse); Der Funktionsaufruf. Hier muss nun die (Anfangs)-Adresse der Struktur übergeben werden Prof. Martin Trauth Folie 11 / 19
9.11 Der Strukturoperator Wenn Strukturen by reference als Funktionsparameter verwendet wurden, kann man in der aufgerufenen Funktion auf die Werte der Strukturkomponenten so zugreifen: <Wert> = (* <Name des Pointers auf Strukturvariable>).<Komponentenname>; Beispiel. nr = (* padresse).hausnr; Die Klammern sind hier notwendig, da der Punktoperator eine höhere Priorität als der Inhaltsoperator (*) hat. Da diese Schreibweise etwas umständlich ist, wird der sog. Strukturoperator (Schreibweise ->) verwendet. Syntax: <Wert> = <Name des Pointers auf Strukturvariable> -> <Komponentenname>; Beispiel. nr = padresse -> hausnr; Der Pfeil tritt an Stelle des Punktes, wenn nicht die Strukturvariable selbst, sondern ein Pointer auf diese Strukturvariable eingesetzt wird. Prof. Martin Trauth Folie 12 / 19
9.12 Strukturen als Funktionsparameter (by reference) Beispiel 1 Dieses Beispiel verdeutlicht den Umgang mit dem Strukturoperator #include <stdio.h> struct vector { double x; double y; ; main() { void tauschen(struct vector *); // Prototyp struct vector vec1 = {15.1, 8.3; printf("\nvorher: %f %f", vec1.x, vec1.y); tauschen(&vec1); printf("\nnachher: %f %f\n", vec1.x, vec1.y); void tauschen(struct vector * vec) { double cach; cach = vec->x; vec->x = vec->y; vec->y = cach; Prof. Martin Trauth Folie 13 / 19
9.13 Strukturen als Funktionsparameter (by reference) Beispiel 2-1 Dieses Beispiel ist komplexer. Es zeigt, wie mit Strukturfeldern umgegangen wird. Zuerst mit einem Feldelement als Parameter. #include <stdio.h> #include <string.h> struct waren { char bezeichnung[40]; double preis; lagerware[500] ; int read_it(struct waren *); // Prototyp, hier außerhalb von main() main() { int i = 0, j; printf("\nbitte Warendaten eingeben! Leerzeile bricht Eingabe ab"); while (read_it(&lagerware[i])) i++; if (i > 0) { for (j = 0; j < i; j++) { printf("ware: %s\n", lagerware[j].bezeichnung); printf("preis: %.2lf Euro\n\n", lagerware[j].preis); Prof. Martin Trauth Folie 14 / 19
9.14 Strukturen als Funktionsparameter (by reference) Beispiel 2-2 Die Funktion read_it (): int read_it(struct waren *eingang) { double preis1; char string1[80]; fflush(stdin); printf("\nbezeichung:"); gets(string1); if (strlen(string1)!= 0) { strcpy(eingang->bezeichnung, string1); printf("\npreis:"); scanf("%lf", &preis1); eingang->preis = preis1; return 1; else return 0; Prof. Martin Trauth Folie 15 / 19
9.15 Strukturen als Funktionsparameter (by reference) Beispiel 3-1 Dieses Beispiel wurde modifiziert. Nun wird das gesamte Strukturfeld by reference übergeben. #include <stdio.h> #include <string.h> struct waren { char bezeichnung[40]; double preis; lagerware[500] ; int read_it(struct waren *, int); main() { int i = 0, j; printf("\nbitte Warendaten eingeben! Leerzeile bricht Eingabe ab"); while (read_it(lagerware, i)) i++; // in der Schleife gibt es nur i++ if (i > 0) { for (j = 0; j < i; j++) { printf("ware: %s\n", lagerware[j].bezeichnung); printf("preis: %.2lf Euro\n\n", lagerware[j].preis); Kein Adressoperator vor lagerware, weil es ein komplettes Feld ist! Prof. Martin Trauth Folie 16 / 19
9.16 Strukturen als Funktionsparameter (by reference) Beispiel 3-2 Die Funktion read_it () für den Zugriff auf das gesamte Feld (benötigt daher in unserem Beispiel den Feldindex als Parameter): int read_it(struct waren *eingang, int n) { double preis1; char string1[80]; fflush(stdin); printf("\nbezeichung:"); gets(string1); if (strlen(string1)!= 0) { strcpy(eingang[n].bezeichnung, string1); printf("\npreis:"); scanf("%lf", &preis1); eingang[n].preis = preis1; return 1; else return 0; Kein Strukturoperator bei den Komponenten von Struktur-Feldern. Durch den Feldindex wird bereits der Zugriff auf den Inhalt des indizierten Feldelements (bzw seiner Strukturkomponente) bewirkt. Prof. Martin Trauth Folie 17 / 19
9.17 Enumerationen (Aufzählungstyp) Enumerationen sind eigentlich Listen von Bezeichnungen, denen Zahlenwerte zugewiesen werden. Ein Beispiel (bitte geschweifte Klammern beachten): enum noten {sehr_gut = 1, gut, befriedigend, ausreichend, mangelhaft, ungenuegend; Den Bezeichnungen in der Liste werden natürliche Zahlenwerte in aufsteigender Folge zugewiesen. Eigentlich würde mit 0 begonnen werden. Durch das Gleichheitszeichen kann man aber den Wert jedes Listenelements erzwingen, Dadurch ist es auch möglich zwei Bzeichnungen mit gleichem Zahlenwert zu erhalten. enum bool {false, falsch = 0, true, wahr = 1, richtig = 1; Wie bei Strukturen wird der Enumerationstyp Variablen zugewiesen. enum bool logikwert; Alternative: wie bei Strukturen den Variablennamen hinter die Liste schreiben. Wird der Variablen nun im Programm eine Bezeichnung aus der Liste zugewiesen, dann nimmt sie den entsprechenden Zahlenwert an. Das ist oft übersichtlicher als die Zuweisung einer reinen Zahl. logikwert = false; Die Variable logikwert hat dann den Wert 0. Prof. Martin Trauth Folie 18 / 19
9.18 Unions Unions werden auch Verbunde oder Varianten genannt. Ihr Hauptzweck ist das Einsparen von Speicherplatz. Sie können aber auch trickreich für die Umformung gespeicherter Werte benutzt werden. union saveit {double zahl; char zeichen[10]; mysafe; Die Syntax entspricht der von Strukturen (Unions können übrigens auch Strukturkomponenten sein). Wie bei Strukturen ist es auch bei Unions möglich, die zu deklarierende Variable gleich hinter die Liste zu schreiben. Im Beispiel wurde das so gemacht. Unions speichern allerdings alle Komponenten unter der gleichen Speicheradresse (bzw Startadresse). Im Beispiel benötigt die double-variable zahl 8 Byte. Das char-feld nimmt 10 Byte in Anspruch. Speicherplatzbedarf ist daher 10 Byte. Immer wenn eine Komponente zugewiesen wird, werden die entsprechenden Bytes der anderen Komponente überschrieben. strcpy(mysafe.zeichen, "Hans"); mysafe.zahl = -15.8 Wenn man danach die Zeichenkette in mysafe.zeichen ausgeben wollte, käme mit Sicherheit irgendwas heraus, aber nicht Hans. Es gibt Datensätze, in denen entweder die eine oder die andere Komponente benötigt wird, aber niemals beide. In diesen Fällen sind Unions nützlich. Aber das kommt nicht so häufig vor, weshalb Unions wesentlich seltener verwendet werden als z.b. Strukturen. Prof. Martin Trauth Folie 19 / 19