Objektbasierte Entwicklung

Transkript

1 Objektbasierte Entwicklung Die kanonische Form von C Strukturen und was haben Abstrakte Datentypen mit der JVM zu tun? Prof. Dr. Nikolaus Wulff

2 ADT in C Objekte mit gemeinsamen Attributen und Verhalten werden als Instanzen einer Klasse modelliert. Beispiele: Konto, Kunde, Buchung etc. C kennt zwar keine Klassen, es lassen sich jedoch mit Strukturen entsprechende Abstrakte Datentypen definieren. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 2

3 Klassen in C Gemeinsame Attribute lassen sich in C mit Hilfe einer Struktur in einer *.h Datei definieren: struct konto_struct { char* waehrung; char* kontonr; double saldo; }; Das gemeinsame Verhalten aller Konto Instanzen wird durch entsprechende Methoden abgebildet: extern double getsaldo(struct konto_struct* konto); Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 3

4 C Strukturen Die im Header deklarierten Strukturen und Methoden stellen die öffentliche Schnittstelle der modellierten Klasse da: Zwei Attribute kontonr, saldo sowie die Methode getsaldo. Damit die Methode auf dem jeweiligen Konto operieren kann wird eine Referenz auf die Struktur des Kontos übergeben. Die Implementierung in Konto.c ist trivial: #include "Konto.h" double getsaldo(struct konto_struct* konto) { return konto->saldo; } Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 4

5 Verwendung der C Klasse Die Verwendung dieses ADT könnte so aussehen: #include <stdio.h> #include "Konto.h" int main(int argc, char* argv[]) { struct konto_struct konto = {"Euro","08-a",10000}; printf("konto %s hat ein Saldo von %f %s\n", getkontonr(&konto), getsaldo(&konto), getwaehrung(&konto) ); } return 0; Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 5

6 Eigene Typen definieren Lästig ist die Pointer Arithmetik und das Offenlegen der Struktur. Hier erweist sich die Definition eines eigenen Typen per typedef als nützlich: typedef struct konto_struct* Konto; Die Methode double getsaldo(struct konto_struct* konto); kann dann prägnanter geschrieben werden als: double getsaldo(konto konto); Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 6

7 Verwendung des ADTs #include <stdio.h> #include <stdlib.h> #include "Konto.h" int main(int argc, char* argv[]) { Konto konto = newkonto(euro, " ", 10000); } printf("konto %s hat ein Saldo von %f %s\n", getkontonr(konto), getsaldo(konto), getwaehrung(konto) ); free(konto); return 0; Konten sind jetzt Pointer und erfordern malloc und free! Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 7

8 Klassen erweitern Die Methode getsaldo erscheint auf dem ersten Blick überflüssig, das Attribut saldo kann auch direkt der Struktur entnommen werden... Was ist jedoch bei unterschiedlichen Ausprägungen von Konto, z.b. einem Fremdwährungskonto bei dem der aktuelle Wert berechnet werden muss? Hierzu muss die Kontostruktur entsprechen erweitert werden. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 8

9 Vererbung in C Das Fremdwährungskonto ist eine Spezialisierung eines Kontos mit zusätzlichen Attributen und nach außen gleichem Verhalten: typedef struct fremdwaehrungs_konto_struct { char* waehrung; char* kontonr; double saldo; double konvertierung; } *FremdKonto; Ein solches Fremdkonto kann wie ein Konto verwendet werden. Es muß jedoch die getsaldo Methode anders darauf reagieren. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 9

10 Methoden erweitern Die Methode getsaldo reagiert je nach Kontoausprägung unterschiedlich: double getsaldo(konto konto) { double saldo = konto->saldo; if (!strcmp(euro, konto->waehrung)) { } saldo *= ((FremdKonto)konto)->konvertierung; } return saldo; Handelt es sich um ein Fremdwährungskonto wird entsprechend umgerechnet. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 10

11 Das Methoden Problem Es stört, das die Methode getsaldo für jede mögliche Kontoart anders reagieren muss. Die Alternative zwei unterschiedliche Methoden getsaldo und getsaldofremdwaehrung zu implementieren klingt auch nicht gut, denn der aufrufende Client sieht dann nicht mehr eine einheitliche Konto Schnittstelle. Hierzu bietet es sich an die Methoden zu überladen und an den jeweiligen Kontostrukturen zu verankern. C kennt hierzu das Konstrukt eines Pointers auf eine Methode. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 11

12 Function Pointer Die aufzurufende Methode wird direkt an der Struktur notiert: struct konto_struct { char* waehrung; char* kontonr; double saldo; double (*getsaldo)(konto konto); }; Beim Erzeugen der unterschiedlichen Konto Typen muß im newkonto Konstruktor der Pointer auf eine entsprechende Methode gesetzt werden. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 12

13 Überladene Methoden Die Methoden werden mit dem static Attribute auf private gesetzt und sind von außen nicht aufrufbar: static double geteurosaldo(konto konto) { double saldo = konto->saldo; return saldo; } static double getforeignsaldo(konto konto) { double saldo = konto->saldo; saldo *= ((FremdKonto)konto)->konvertierung; return saldo; } Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 13

14 Ein C Konstruktor Konto newkonto(char* waehrung, char* kontonr, double saldo) Konto konto; if (!strcmp(euro, waehrung) ) { konto = (Konto) malloc(sizeof(struct konto_struct)); konto->getsaldo = geteurosaldo; } else { konto = (Konto) malloc(sizeof(struct fremdwaehrungs_ konto->getsaldo = getforeignsaldo; Konto->konvertierung = getkonvertierung(waehrung); } konto->waehrung = waehrung; konto->kontonr = kontonr; konto->saldo = saldo; return konto; } Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 14

15 Transparenter Methodenaufruf Der Aufruf der unterschiedlichen Konten ist jetzt bis auf den Konstruktor identisch: Konto konto = newkonto(euro, " ",10000); Konto fremd = newkonto(usd, " ", 500); printf(" EuroKonto %f \n", konto->getsaldo(konto) ); printf(" FremdKonto %f \n",fremd->getsaldo(fremd) ); Beim Fremdkonto wird jedoch automatisch eine andere Implementierung der getsaldo Methode aufgerufen, ohne das der Aufrufer diese bemerkt! Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 15

16 Doppelte Verkettung Was stört, ist die doppelte Verwendung der Konto Struktur: konto->getsaldo(konto); Zum einen enthält die Kontostruktur den Pointer auf die zu verwendende Methode, zum anderen benötigt diese Methode genau die Attribute der Struktur zum Berechnen des Saldos... Hier kann der Präprozessor kosmetisch helfen: #define actualsaldo(k) (k)->getsaldo((k)) printf(" Saldo von %f \n", actualsaldo(konto) ); Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 16

17 Ein Diagramm Editor Ein Diagramm Editor soll generische 2D-Objekte zeichnen und verwalten können. Es gibt unterschiedliche 2D-Objekte, wie Rechtecke, Kreise, Textfelder, etc. Die 2D-Objekte werden durch den ADT Shape modelliert, der den abstrakten Oberbegriff und die gemeinsamen Attribute und Methoden bereitstellt. Shapes werden durch eine entsprechende C Struktur implementiert. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 17

18 Diagramm Editor Design Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 18

19 Verkettung von Strukturen Die Struktur eines Shapes ist für alle geometrischen Objekte einheitlich: #ifndef SHAPE_H_ #define SHAPE_H_ #include <assert.h> #include <stdarg.h> typedef struct shape_struct* Shape; struct shape_struct { int x; int y; void (*draw) (Shape ashape); }; Shape.h Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 19

20 Erweiterungen von Strukturen Die zusätzlichen Argumente des Rechtecks werden dann hinten angehängt : #ifndef RECT_H_ Rect.h #define RECT_H_ #include "Shape.h" typedef struct rect_struct* Rect; struct rect_struct { int x; int y; void (*draw) (Shape ashape); int w; int h; }; Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 20

21 Casting von Strukturen Die unterschiedlichen Pointer von Shape Strukturen lassen sich gefahrlos aufeinander casten, solange die Strukturen zueinander kompatibel sind: Shape int x; int y; draw Cast-Grenze Circle int x; int y; draw int r; drawcircle Rect int x; int y; draw int w; int h; drawrect Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 21

22 Gefährliches Casten Diese Art von Strukturvererbung ist zwar sehr elegant aber auch sehr gefährlich. Was ist wenn die Shape.h Struktur verändert wird ohne das Rect.h angepasst wird? Shape char t; int x; int y; draw Circle int x; int y; draw int r; xfe32 10 xfe32:drawcircle Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 22

23 Gefährliches Casten Wird ein solches Rect Struct auf ein Shape gecasted so ist dies auf Grund der Strukturveränderung nicht mehr konform. Der Methoden Pointer zeigt in den Datenbereich und wird zu einem Absturz führen. Circle Shape 10:Nirwana char int x; t; int y; x; draw inty; draw int r; xfe32 10 xfe32:drawcircle Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 23

24 Automatisierung der Vererbung Gesucht wird eine Möglichkeit diese gefährlichen Seiteneffekte zu verhindern: struct p2d { int x; int y; }; struct p2d { int x; int y; }; struct p3d { int x; int y; int z; }; struct p3d { struct p2d p2; int z; }; Die rechte Version garantiert, dass alle Änderungen von p2d automatisch auch für p3d gelten. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 24

25 Vererbung versus Aggregation Leider drückt die rechte Seite nicht dasselbe wie die linke Seite aus. Wir versuchen mit C Vererbung zu emulieren. Die rechte Seite modelliert jedoch keine Vererbung sondern eine Aggregation! Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 25

26 Verwendung von Point3D Der Unterschied wird sehr schnell deutlich, wenn die rechte Variante instanziiert und verwendet wird: struct p2d point2 = { 2, 4 }; struct p3d point3 = { {1, 4}, 5}; struct p3d another= { point2, 5}; point2.x = 1; point2.y = 0; point3.p2.x = 3; point3.p2.y = 4; point3.z = 3; point3 enthält eine Instanz von p2d. Er ist jedoch kein Subtyp von p2d. anonymous structs seit C11 können helfen Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 26

27 Automatisierung durch Macros Die einzige Chance hier weiter zu kommen ist es den C Präprozessor einzusetzen. #define ATTRIBUTE_2D() \ int x,y; #define ATTRIBUTE_3D() \ ATTRIBUTE_2D() \ int z; struct p2d { ATTRIBUTE_2D() }; struct p3d { ATTRIBUTE_3D() }; Änderungen an der 2D Struktur werden automatisch auch an die 3D Struktur propagiert. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 27

28 Operationen Bis lang konzentrierte sich alles auf die Attribute der mit C-Structs modellierten Shapes. Was ist wenn weitere Methoden hinzukommen? struct shape_struct { int x; int y; void (*draw) (Shape ashape); void (*moveto) (Shape ashape, int x, int y); void (*erase) (Shape ashape); }; Die Shapes unterscheiden sich nur durch ihre Attribute. Alle Shapes vom selben Typ müssen die gleichen Operationen und Methodenpointer haben. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 28

29 GTK Separationsansatz Das Linux Graphical Toolkit GTK ist ein gutes Beispiel für ein modulares Design. Es ist vollkommen in C programmiert, bietet jedoch eine objektorientierte API an. Jedes graphische Element ist als ein GtkWidget modelliert, dass entsprechende Methoden zur Verfügung stellt. Die Attribute und die zugehörigen Methoden werden in zwei getrennten Structs modelliert. => Der Speicherplatz für die Methoden wird nicht pro Instanz benötigt sondern geteilt. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 29

30 Shapes revisited Die Aufteilung in Methoden und Attribute erfolgt in zwei Structs XXX_Instance und XXX_Class: typedef struct shape_instance* Shape; typedef struct shape_class { void (*draw) (Shape ashape); void (*erase) (Shape ashape); void (*moveto) (Shape ashape, int x,int y); } ShapeClass; struct shape_instance { ShapeClass *class; int x; int y; }; Jede Instanz hat einen Pointer auf die Methoden. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 30

31 Der kanonische C ADT Die kanonische Form besteht aus zwei Strukturen: Eine Struktur für das Verhalten, sie repräsentiert die Methoden und stellt das Klassengerüst dar. Eine Struktur für den Zustand, sie repräsentiert die Attribute und stellt Instanzen dar. typedef struct ADT_Instance* ADTInstance; typedef struct ADT_Class { rettype (*adtmethod) (ADTInstance obj); } ADTClass; struct ADT_Instance { ADTClass *class; attrtype adtvariable; }; Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 31

32 Java Klassen und Objekte Die JVM verwaltet auf diese Art Klassen und ihre zugehörigen Instanzen/Objekte. Zu jedem Objekt kann mit obj.getclass() die Klasse ermittelt werden. Das class Objekt verwaltet u.a. alle Methoden. Per Reflection API kann auf diese Methoden Zeiger zugegriffen und das Objekt manipuliert werden. Diese API ist auch zum Verständnis von Java Native Calls per JNI wichtig. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 32

33 Shapes kanonische Form Die Aufteilung in Methoden und Attribute erfolgt in zwei Structs XXX_Instance und XXX_Class: typedef struct Shape_Instance_struct* Shape; typedef struct Shape_Class_struct { void (*draw) (Shape ashape); void (*erase) (Shape ashape); void (*moveto) (Shape ashape, int x,int y); } ShapeClass; typedef struct Shape_Instance_struct { ShapeClass *class; int x; int y; } ShapInstance; Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 33

34 Rect kanonische Form Die Rect Strukturen sind fast identische Kopien der Shape Strukturen: typedef struct Rect_Instance_struct* Rect; typedef struct Rect_Class_struct { void (*draw) (Shape ashape); void (*erase) (Shape ashape); void (*moveto) (Shape ashape, int x,int y); void (*resize) (Shape ashape, int w,int h); } RectClass; typedef struct Rect_Instance_struct { RectClass *class; int x; int y; int w; int h; } RectInstance; Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 34

35 Präprozessoroperatoren Der Präprozessor kann helfen solche generischen Strukturen, die fast identische Kopien sind und sich nur durch Namen entscheiden, zu generieren. Es lassen sich Macros definieren, die als Vorlagen ähnlich den C++ Templates dienen und den Quellcode durch Textersetzung erzeugen. Eine wichtige Rolle spielen hierbei die beiden Präprozessoroperatoren # und ##: # setzt den Parameter in Hochkomma als String ## konkateniert zwei Symbole zu Einem Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 35

36 Zeichen Macros #define makestr(x) #x #define concat(x,y) x ## y Der Ausdruck makestr(hello) wird dann zum String "hello" expandiert. Der Ausdruck concat(shape, Class) ergibt das Symbol ShapeClass (nicht als String!). Mit diesen beiden Operatoren lassen sich Quelltexte generieren. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 36

37 C Klassen per Makros Die kanonische Aufteilung in Instanz und Class Strukturen lässt sich per Coding by Convention durch Makros erzwingen und generieren. BEG_DEFINE_CLASS(T) generiert die Class Struktur zum Typen T. BEG_DEFINE_INSTANCE(T) generiert die Instanz Struktur zum Typen T und beinhaltet auch den Zeiger auf die Class Struktur. Ähnlich wie bei C++ Templates oder Java Generics ist T ein Platzhalter für den Typen, z.b. Shape. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 37

38 Shapes per Macro generieren #define BEG_DEFINE_CLASS(T) \ typedef struct T##_Instance_struct* T; \ typedef struct T##_Class_struct { #define END_DEFINE_CLASS(T) \ } T##Class; #define BEG_DEFINE_INSTANCE(T) \ typedef struct T##_Instance_struct { \ T##Class *clazz; #define END_DEFINE_INSTANCE(T) \ } T##Instance; \ extern T new##t(int* args); Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 38

39 Shape Attribute + Methoden #define SHAPE_METHODES \ void (*draw) (Shape ashape); \ void (*erase) (Shape ashape); \ void (*moveto) (Shape ashape, int x,int y); #define SHAPE_ATTRIBUTES \ int x; \ int y; Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 39

40 Cleveres malloc Mit dem Präprozessor lässt sich auch der malloc Aufruf vereinfachen und typsicher machen: #define alloc(t) (T) malloc( \ sizeof(t ## Instance)) Mit diesem Macro wird immer Code zum passenden ADT erzeugt und die Verwendung von malloc vereinfacht sich von: Rect obj = (Rect) malloc( sizeof(struct Rect_Instance_struct)); zu: Rect obj = alloc(rect); Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 40

41 Shape.h mit Macros BEG_DEFINE_CLASS(Shape) SHAPE_METHODES END_DEFINE_CLASS(Shape) BEG_DEFINE_INSTANCE(Shape) SHAPE_ATTRIBUTES END_DEFINE_INSTANCE(Shape) So einfach und aufgeräumt kann eine *.h Datei sein Allerdings sind die Strukturen schwieriger zu verstehen, da die Macros vieles verstecken. Rect.h wird mit genau den selben Macros erzeugt. Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 41

42 Rect.h mit Macros #ifndef RECT_H_ #define RECT_H_ #include "Shape.h" BEG_DEFINE_CLASS(Rect) RECT_METHODES SHAPE_METHODES void (*resize) (Rect r, int w, int h); END_DEFINE_CLASS(Rect) BEG_DEFINE_INSTANCE(Rect) SHAPE_ATTRIBUTES int w; RECT_ATTRIBUTES int h; END_DEFINE_INSTANCE(Rect) #define size(r,x,y) R->clazz->resize(R, (x), (y)) #endif /* RECT_H_ */ Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 42

43 Rect kanonische Form Diese einfachen Macro Templates generieren zur Compile Zeit die komplette Rect Header Datei: typedef struct Rect_Instance_struct* Rect; typedef struct Rect_Class_struct { void (*draw) (Shape ashape); void (*erase) (Shape ashape); void (*moveto) (Shape ashape, int x,int y); void (*resize) (Shape ashape, int w,int h); } RectClass; typedef struct Rect_Instance_struct { RectClass *class; int x; int y; int w; int h; } RectInstance; Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 43

44 Rect.c static void resize(rect obj, int h, int w) { obj->h = h; obj->w = w; } static RectClass rectclass = {draw, erase, moveto, resize }; Shape newrect(int args[]) { Rect obj = alloc(rect); obj->clazz = &rectclass; obj->x = args[0]; obj->y = args[1]; obj->h = args[2]; obj->w = args[3]; return (Shape) obj; } Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 44

45 Vererbung automatisieren Eine Vererbungshierarchie lässt sich durch zwei weitere Makros EXTENDS und INSTANCE_OF deklarativ implementieren: BEG_DEFINE_CLASS(Circle) EXTENDS(Shape) METHODS(Circle) END_DEFINE_CLASS(Circle) BEG_DEFINE_INSTANCE(Circle) INSTANCE_OF(Shape) ATTRIBUTES(Circle) END_DEFINE_INSTANCE(Circle) Wie sind EXTENDS und INSTANCE_OF definiert? Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 45

46 Kürzer geht es nicht... Wem selbst dies noch zu viel ist, der kann noch das Makro DEFINE_BASE_TYPE für eine Wurzelklasse wie z.b. Shape DEFINE_BASE_TYPE(Shape) und DEFINE_EXTENDED_TYPE für eine Kindklasse wie z.b. Rect definieren: DEFINE_EXTENDED_TYPE(Rect,Shape) Debugen wird schwieriger mit gcc save-temps kann der generierte Code gespeichert werden... Prof. Dr. Nikolaus Wulff Höhere Programmierkonzepte 46