Abgeleitete Datentypen (1) Richtlinien

Transkript

1 Abgeleitete Datentypen (1) Richtlinien Verbunddatentypen erlauben durch Kombination und Verschachteln beliebige komplexe Datenstrukturen Entwurf von Datenstrukturen hat wesentlichen Einfluss auf Art und Weise, wie Algorithmen darauf zugreifen können Entwurf auf Hinblick verwendeter Algorithmen Verwendung von struct und union Möglichst einfach und verständlich aufbauen Vermeidung von zu tiefen Verschachtelungsebenen Vermeidung hoher Anzahl von Attributen, besser kleinere, problemorientierte Datentypen Definition von Funktionen, die darauf zugreifen (interface functions) Vermeidung von redundanten Strukturen

2 Abgeleitete Datentypen (2) Strukturen Mit struct-vereinbarung kann ein neuer Datentyp aus vorhandenen zusammengesetzt werden struct Strukturname { Typ Attributname; //... Beispiel für Struktur Punkt_s, die Koordinaten eines Punktes speichert struct Punkt_s { double x, y;

3 Abgeleitete Datentypen (3) Strukturen Erzeugen von Variablen folgt nach dem Muster: struct Strukturname Variablenliste; Beispiel für struct-variablen, die auf der vorherigen Folie definiert wurden: struct Punkt_s p1, p2; In C kann man auch Strukturdefinition und Variablendefinition in einem Rutsch zu erledigen: struct Strukturname { Typ Attributname; //... } Variablenliste Beispiel mit den Koordinaten: struct Punkt_s { double x, y; } p1, p2; Besser ist, Definition und Initialisierung zu trennen (übersichtlicher)

4 Abgeleitete Datentypen (4) Strukturen Typdefinitionen möglichst in Header-Dateien sammeln Verfügbarkeit für mehrere Module Trennung von Datentypdefinition und Programmtext // Datei grafik.h struct Punkt_s { double x, y; //... // Datei grafik.c #include "grafik.h" //... struct Punkt_s p1, p2; //...

5 Abgeleitete Datentypen (5) Strukturen Initialisierung von Struktur-Variablen: struct Punkt_s p1 = { 4, 3 }, p2; Im Beispiel werden Variablen p1 und p2 definiert, p1 wird auch initialisieret, p2 hingegen nicht Initialwerte werden durch Kommas voneinander getrennt Auf Attribute der Struktur-Variablen kann mittels Punkt-Operator zugegriffen werden p2.x = 4; p2.y = 3;

6 Abgeleitete Datentypen (6) Strukturen Beispiel zur Berechnung des Euklidischen Abstands zweier Punkte: #include <math.h> //... double dist, dx, dy; //... dx = p2.x - p1.x; dy = p2.y - p1.y; dist = sqrt(dx * dx + dy * dy);

7 Abgeleitete Datentypen (7) Strukturen Beispiel zur Verschachtelung von Strukturen: struct Rechteck_s { struct Punkt_s pmin, pmax; Auch verschachtelte Strukturen lassen sich initialisieren: struct Rechteck_s r = { { 4, 3}, {15, 8}, Zugriff auf Elemente erfolgt wieder mittels.-operator: double flaeche; //... flaeche = (r.pmax.x - r.pmin.x) * (r.pmax.y - r.pmin.y);

8 Abgeleitete Datentypen (8) Strukturen Kopieren von Strukturen wird über den Zuweisungsoperator realisiert p2 = p1; // Kopiert die komplette Struktur p1 nach p2

9 Abgeleitete Datentypen (9) Funktionen und Strukturen Struktur-Variablen können ähnlich verwendet werden wie Variablen eingebauter Typen: struct Rechteck_s NeuesRechteck(const struct Punkt_s p1, const struct Punkt_s p2) { struct Rechteck_s rect; rect.pmin = p1; rect.pmax = p2; return rect; } Zwei Punkte werden übergeben und als Rechteck wieder zurückgegeben const bewirkt, dass die Daten nur gelesen werden

10 Abgeleitete Datentypen (10) Funktionen und Strukturen Folgende Erweiterung des Beispiels bewirkt, dass das Attribut pmin in der linken unteren Ecke und pmax in der rechten oberen Ecke landet struct Rechteck_s NeuesRechteck(const struct Punkt_s p1, { struct Rechteck_s rect; } const struct Punkt_s p2) rect.pmin.x = MIN(p1.x, p2.x); // früher vorgestellte MIN- und rect.pmin.y = MIN(p1.y, p2.y); // MAX-Makros rect.pmax.x = MAX(p1.x, p2.x); rect.pmax.y = MAX(p1.y, p2.y); return rect; Zur Übergabe der Funktionswerte werden Kopien der Parameter angelegt und zurückgegeben Problem, wenn große Datenmengen bei Datenmengen > 8 Byte besser Zeiger verwenden

11 Abgeleitete Datentypen (11) Zeiger auf Strukturen Wie gezeigt, ist es vorteilhaft, Zeiger zu verwenden, statt Kopien größerer Strukturen anzulegen struct Punkt_s p1 = {4, 3 struct Punkt_s *pp = &p1; Adresse der Strukturvariablen wird mit dem Adressoperator ermittelt Um auf Element x zuzugreifen, könnte man schreiben (*pp).x Klammerung ist notwendig, da der Punkt-Operator eine höhere Priorität hat Umständliche Schreibweise, stattdessen Verwendung des Selektionsoperators pp->x Hole das Attribut x aus dem Objekt, auf das pp zeigt. (korrekte Interpretation) pp zeigt auf x. (übliche Interpretation, aber nicht korrekt, da Zeiger pp auf p1 zeigt und nicht auf x)

12 Abgeleitete Datentypen (12) Zeiger auf Strukturen Modifikation des Rechteckbeispiels mit Zeigern: void NeuesRechteck( struct Rechteck_s * const rectp, const struct Punkt_s * const pp1, const struct Punkt_s * const pp2) { rectp->pmin.x = MIN(pp1->x, pp2->x); rectp->pmin.y = MIN(pp1->y, pp2->y); rectp->pmax.x = MAX(pp1->x, pp2->x); rectp->pmax.y = MAX(pp1->y, pp2->y); } // end NeuesRechteck Interpretation von rectp->pmin.x: rectp zeigt auf pmin Punkt x. Die Originaldaten werden per Zeiger an die Funktion übergeben Konstante Zeiger (Adressen können also nicht verändert werden) Übergebene Inhalte können nicht verändert werden const struct Punkt_s Rückgabewert muss beschreibbar sein (const fehlt hier)

13 Abgeleitete Datentypen (13) Zeiger auf Strukturen Abwägen, wann besser Kopien übergeben werden sollten und wann Zeiger Zeiger: Arbeiten an Originaldaten, performante Datenübergabe Kopien: sicher, da eine Originaldaten, Parameterübergabe nicht performant, da Kopien

14 Abgeleitete Datentypen (14) Felder von Strukturen Exemplarisches Beispiel: #define ADRESSE_NAME_LEN 30 #define ADRESSE_ORT_LEN 20 #define ADRESSE_STRASSE_LEN 50 struct Adresse_s { char name[adresse_name_len]; // Name der Person long plz; // Postleitzahl char ort[adresse_ort_len]; // Wohnort char strasse[adresse_strasse_len]; // Strasse long nummer; // Hausnummer #define ADRESSBUCH_LEN 100 struct Adresse_s Adressbuch[ADRESSBUCH_LEN];

15 Abgeleitete Datentypen (15) Felder von Strukturen Initialisierung wie bei Feldern ebenfalls möglich: struct Adresse_s KleinesAdressBuch[3] = { { "Joseph Haydn", 2471, "Rohrau", "Obere Hauptstraße", 25 }, { "Franz Schubert", { "Wolfgang Amadeus Mozart", 1090, 5020, "Wien", "Salzburg", "Nußdorfer Straße", "Getreidegasse", 54 9 } }, Statische und globale Variablen werden mit 0 initialisiert Bei unvollständigen Initialisierungen wird Rest mit 0 initialisiert

16 Abgeleitete Datentypen (16) Felder von Strukturen Zugriff auf Feldelemente: Auswahl an der Stelle, wo das Feld definiert ist: KleinesAdressBuch[0].nummer = 23; Die einzelnen Attribute werden wie die zugehörigen Basisvariablen behandelt, beispielsweise Kopieren von Zeichenketten: strcpy(kleinesadressbuch[0].name, "Johannes Brahms"); Adressierung eines einzelnen Zeichens aus der Zeichenkette erfolgt mittels KleinesAdressBuch[0].name[0] = J ;

17 Abgeleitete Datentypen (17) Bitfelder Für speicherkritische Anwendungen Wahrheitswerte struct Bitfelder_s { unsigned int a : 1; // Bitfeld der Länge 1 unsigned int b : 2; // Bitfeld der Länge 2 unsigned int c : 3; // Bitfeld der Länge 3 unsigned int d : 5; // Bitfeld der Länge 5 Nur Typ int erlaubt, Angabe von unsigned oder signed aus Portabilitätsgründen Bitfeld mit den Attributen a, b, c, d enthält 1, 2, 3, 5 Bits

18 Abgeleitete Datentypen (18) Bitfelder Anonyme Bitfelder struct Bitfelder_s { unsigned int a : 10; // Bitfeld der Länge 10 unsigned int : 6; // Anonymes Bitfeld unsigned int b : 10; // Bitfeld der Länge 10 unsigned int : 0; // Anonymes Bitfeld signed int c : 2; // Bitfeld der Länge 2 Wird kein Attributname angegeben, wird hier eine Lücke von n Bits eingefügt

19 Abgeleitete Datentypen (19) Bitfelder Zugriff auf Bitfelder wie bei allen anderen Variablen auch: struct Bitfeld_s bf; //... bf.a = 36; bf.b = 29; bf.c = -1;

20 Abgeleitete Datentypen (20) Unions Bei regulären Strukturen (structs, Bitfelder) haben die Datenelemente im Speicher aufeinanderfolgende Adressen Bei varianten Strukturen (unions) haben die Datenelemente die gleiche Adresse Resultierender Effekt bei Beschreiben eines Attributes: alle Attribute werden beschrieben, da sie an gleicher Stelle im Speicher stehen Unions werden eingesetzt, wenn Verschiedene Attribute zusammengefasst werden sollen, die nicht gleichzeitig auftreten können (z.b. geometrische Struktur ist Kreis oder Rechteck, kann aber nicht beides sein) Auf komplexe Datenstrukturen auf unterschiedliche Art und Weise zugegriffen werden soll )z.b. Datentelegramme) Definition mit dem Schlüsselwort union Nutzung äquivalent zu struct (unter Beachtung der unterschiedlichen Eigenschaften)

21 Abgeleitete Datentypen (21) Unions Definition einer varianten Struktur: union Unionname_u { Typ Attributname; //... Beispiel: ganzezahl union punktoderganzezahl { double punktzahl; long ganzezahl; punktzahl double belegt 64 Bit und long belegt auf 32-Bit-Rechnern nur 32 Bit Länge entspricht der des längsten Elementes

22 Abgeleitete Datentypen (22) Unions Definition einer union-variable: union Unionname_u Variablenliste; Beispiel: union Zahl_u punktoderganzezahl; Union-Definition und Variablen-Definition in einem Rutsch (nicht empfohlen): union Zahl_u { double punktzahl; long ganzezahl; } punktoderganzezahl; Zugriff auf Elemente a.ganzezahl = 5; // a.ganzezahl ist gültig, a.punktzahl ist ungültig // a.ganzezahl kann verwendet werden a.punktzahl = 1.3; // a.punktzahl ist gültig, a.ganzezahl ist ungültig // a.punktzahl kann verwendet werden

23 Abgeleitete Datentypen (23) Unions Beispiel struct Kreis_s { double x, y; // Position des // Mittelpunktes double r; // Radius struct Rechteck_s { double x, y; // Position des linken // unteren Punktes double b, h; // Breite, Höhe union GeoObjekt_u // Definition einer // varianten Struktur { struct Kreis_s kreis; struct Rechteck_s rechteck; enum GeoObjektTyp_e { GEOTYP_KREIS, GEOTYP_RECHTECK struct GeoObjekt_s { enum GeoObjektTyp_e typ; union GeoObjekt_u geoobjekt;

24 Abgeleitete Datentypen (24) Unions Im Beispiel kann typ einen von zwei angegebenen Möglichkeiten annehmen Ist typ gleich GEOTYP_KREIS, dann enthält die variante Struktur GeoObjekt_u einen Kreis, ist er GEOTYP_RECHTECK, ein Rechteck Beispiel zur Anwendung: struct GeoObjekt_s g; //... // Setzen der Daten für einen Kreis g.typ = GEOTYP_KREIS; g.geoobjekt.kreis.x = 2.3; g.geoobjekt.kreis.y = 4.5; g.geoobjekt.kreis.r = 8; Verwendung verschachtelter Datenstrukturen führt oft zu langen Namen

25 Abgeleitete Datentypen (25) Unions Zur Vermeidung langer Namen kann man eine union anonym (also ohne eigenen Typbezeichner) definieren, was innerhalb einer Strukturdefinition möglich ist: struct GeoObjekt_s { enum GeoObjektTyp_e typ; // GEOTYP_KREIS... Kreis // GEOTYP_RECHTECK... Rechteck union { struct Kreis_s kreis; struct GeoObjekt_s g; struct Rechteck_s rechteck; //... g.typ = GEOTYP_KREIS; g.kreis.x = 2.3; // Der "Name" der anonymen // varianten Struktur entfällt g.kreis.y = 4.5; g.kreis.r = 8; Achtung: es wird vorgetäuscht, dass die Union-Attribute Teil der äußeren Struktur sind

26 Abgeleitete Datentypen (26) Unions Beispiel für Anwendung alternativer Zugriffsmethoden zum Senden eines Datenpaketes union datentelegramm { struct // Struktur und Byte-Array im Speicher überlagert { int telegrammtyp; // Definition des Pakettyps zwecks Identifikation int laenge; // Anzahl der folgenden Bytes int[20]; // eigentliche Daten int crc; // Prüfsumme char[46] byte; // alternativ kann man über das Byte-Array zugreifen union datentelegramm datenfeld; //... for (i = 0; i < sizeof(datentelegramm); i++) sendebyte(datenfeld.byte[i]);

27 Abgeleitete Datentypen (27) Rekursive Strukturen Strukturen, die Verweise auf dieselben Strukturen verweisen Sinnvoll für dynamische Speicherverwaltung, z.b. Aufbau von Listen Beispiel: struct Eintrag_s { struct Eintrag_s *naechster; // Zeiger auf weitere Struktur long wert; // Inhalt des Elementes Es muss ein Zeiger verwendet werden, da innerhalb der Struktur diese nicht noch einmal verwendet werden kann Das Ende einer solchen Rekursion kann man als Nullzeiger angeben

28 Abgeleitete Datentypen (28) Deklaration von abgeleiteten Datentypen Abgeleitete Datentypen können in verschiedenen Programmmodulen verwendet werden (wie z.b. Funktionen) Sind diese an anderer Stelle im Projekt definiert, muss man dem Compiler nur bekannt machen, dass es diesen Datentyp gibt Beispiel: // Deklarationen von abgeleiteten Datentypen struct Punkt_s; union Zahl_u; enum Boolean_e; Erfolgt keine Definition an anderer Stelle, gibt es einen Compilerfehler, da dieser dann nicht weiß, wie groß die Variable ist. Es kann auch keine Adresse für einen Zeiger zugewiesen werden. Wichtig: Unterscheidung zwischen Deklaration und Definition Verwendung von Header-dateien für Typ-Definitionen

29 Abgeleitete Datentypen (29) Typdefinition mit Typedef Typedef definiert einen neuen Namen für einen Variablentyp. Beispiel: typedef char *string; Das Aussehen erinnert an eine Variablendefinition Wird eine Variable vom Typ string definiert, so wird sie effektiv so definiert, wie die scheinbare Variable in der Typdefinition Folgende Zeilen sind daher gleichwertig: char *text1 = "Hallo"; string text2 = "Welt"; Beispiel für eine Zeichenkette mit der Länge 20: typedef char namensfeld[20]; namensfeld name;

30 Abgeleitete Datentypen (30) Typdefinition mit Typedef Verfahren wird gern genutzt, um Programmcode lesbarer zu machen Beispielsweise kann man so die Angabe von struct wegdefinieren: typedef struct Adresse_s { char name[30]; // Name der Person long plz; char ort[20]; // Postleitzahl // Wohnort char strasse[50]; // Straße long nummer; } Adresse_t; // Hausnummer Für die Definition eines Adressbuches kann jetzt folgendes benutzt werden: Adresse_t Adressbuch[100]; Postfix t wird gern verwendet, um einen definierten Variablentypen anzuzeigen Mit typedef wird kein neuer Variablentyp erzeugt sondern nur ein weiterer Name für einen bestehenden Typ geschaffen