Teil IV : Abstrakte Datentypen (ADT)

Transkript

1 Teil IV : Abstrakte Datentypen (ADT) Abstraktion ADT in Modula-2 K. Murmann, H. Neumann, Fakultät für Informatik, Universität Ulm, Abstraktion Rekapitulation Realisation eines Stacks Idee für ADT-Konzept ADTs 1

2 Rekapitulation Bisherige Strukturierungs-/Abstraktionsmittel: (funktionelle) Spezifikation schrittweise Verfeinerung, schwache und starke Abstraktion Prozeduren und Funktionen Definition neuer Typen Datentypen, Prozedurtypen Lokale Gültigkeitsbereiche ( Namensräume): lokale VARs und CONSTs lokale Prozeduren und Funktionen Realisation eines Stacks Wesentlicher Punkt: Bestimmte abstrakte Strukturen können auf verschiedene Arten realisiert werden; von dieser eigentlichen Realisierung kann durch Bereitstellung einer begrenzten Anzahl von Prozeduren/Funktionen abstrahiert werden 2

3 Idee für ADT-Konzept Allgemein bekannt/vereinbart/spezifiziert seien gewisse Dinge und die damit durchführbaren Tätigkeiten Aber: Es existieren viele Möglichkeiten der Darstellung/Implementation der Dinge und damit der Tätigkeiten. Also Datenkapselung (Data Encapsulation): Die Implementation der Daten und Tätigkeiten ist (programmtechnisch und programmier-technisch) von aussen nicht erreichbar, sondern in einem Modul eingekapselt. Die Wechselwirkung mit aussen erfolgt durch eine klar definierte Schnittstelle, i.e. klar definierte Daten- Objekte und klar definierte Prozedur-/Funktionsobjekte. Das Ganze bildet einen ADT. Das Verstecken implementationsspezifischer Details im Implemen-tationsmodul eines ADT heisst Information Hiding. Übrigens: Das ist ein wesentlicher Schritt hin zur objektorientierten Programmierung. Beispiel 1: arabische Dezimalzahlen vs. Römische Zahlen 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,..., 50,..., 105,... I, II,III,IV,V,VI,VII,VIII,IX, X, XI,..., L,..., CV,... Die Eigenschaften der Zahlen sind von ihrer Darstellung unabhängig, nicht jedoch die Rechenarten. Sie bauen auf der spezifischen Zahlendarstellung auf: Additionsschema für arabische Zahlen Additionsschema für römische Zahlen Beispiel 2: Zwei Arten der Multiplikation 123 * 25 = = 3075 (25malige Addition) 123 * Die Multiplikation kann auf verschiedene Arten implementiert werden. Ein ADT versteckt die Art und stellt nach aussen nur die Funktionalität zur Verfügung 3

4 ADTs Unterscheidung: Ein Datentyp ist eine Zusammenfassung von Objekten einer Trägermenge (mit best. Wertebereich) und möglichen (erlaubten) Operationen Ein Abstrakter Datentyp (ADT) entsteht durch die Definition der Eigenschaften eines Datentyps unabhängig von seiner konkreten Realisierung. Die Trägermenge selbst wird (im strengen Sinne) mittels erzeugender Operationen (Konstruktoren) definiert. Beispiel: Spezifikation eines ADT Stack Stack push (Element am Anfang einfügen) Konstruktor pop (Element am Anfang entfernen) Operation top (Element am Anfang ansehen) Operation is_empty (Test: Stack leer?) Operation init_stack (Erzeugung eines leeren Stacks) Konstruktor 1) Typ-Definition des ADT Stack : DATATYPE stack(s) Sorten: S (beliebiger Datentyp) stack (Trägermenge) Operationen: END Konstruktoren: init_stack: { } stack push: stack x S stack Operationen: pop: top: is_empty: stack stack stack S stack BOOLEAN 4

5 2) Verhaltens-Definition des ADT Stack durch Gleichungen (Axiome): Gleichungen (Axiome): 1. is_empty(init_stack()) = TRUE 2. is_empty(push(s,e)) = FALSE 3. pop(push(s,e)) = s 4. top(push(s,e)) = e 5. is_empty(s) (s = push(pop(s),top(s))) Beispiel: Definition eines ADT Nat (natürliche Zahlen) DATATYPE Nat sorts Nat constructors 0 : {} ---> Nat succ : Nat ---> Nat operations plus : Nat Nat ---> Nat times : Nat Nat ---> Nat equations (axioms) plus(0, a) = a plus(succ(a), b) = succ(plus(a, b)) times(0, a) = 0 times(succ(a), b) = plus(times(a, b), b) END. 5

6 Beispiel: Definition eines ADT Binär-Baum DATATYPE Tree(S) sorts S, Tree constructors emptytree maketree operations left right elem depth nodecount : {} ---> Tree : Tree S Tree ---> Tree : Tree ---> Tree : Tree ---> Tree : Tree ---> S : Tree ---> N : Tree ---> N equations (axioms) left(maketree(l, n, R)) = L right(maketree(l, n, R)) = R elem(maketree(l, n, R)) = n depth(emptytree) = 0 depth(maketree(l, n, R)) = 1 + MAX(depth(L), depth(r)) nodecount(emptytree) = 0 nodecount(maketree(l, n, R)) = 1 + nodecount(l) + nodecount(r) END. 1. Implementierung von ADTs ADTs in Pascal ADTs in Modula-2 6

7 ADTs in Pascal + Es ist in Pascal möglich einzuführen benutzdefinierte Trägermengen zugehörige Operationen in Form von Funktionsprozeduren lokale Prozeduren/Funktionen, die innerhalb von Blöcken gelten Es ist in Pascal nicht möglich einzuführen die Trägermengen und Funktionen zu einem einheitlichen Konstrukt zusammenzubinden die Elemente der Trägermengen vor unerlaubtem Zugriff (Verwendung anderer als die definierten Funktionen) zu schützen ADTs in Modula-2 Implementierungsspezifische Details können vollständig im Implementierungsmodul eines ADT versteckt werden Data Encapsulation & Information Hiding öffentlich Schnittstelle Definitionsmodul Implementierungsmodul (verdeckte Info) privat 7

8 Definitions-Modul Definition der Schnittstelle, die das Verhalten eines ADT beschreibt; das bedeutet: Export von Datenobjekten und Prozeduren/Funktionen Implementations-Modul Realisation der Datenobjekte/Datenstrukturen sowie der Prozeduren/Funktionen in lokalen Objekten (Daten und Prozeduren) und exportierten Objekten (siehe Schnittstelle) Aufbau von Definitions- und Implementierungs-Moduln in Modula-2 Definitions-Modul (Schnittstelle) DEFINITION MODULE <Name> <Importliste(n) von anderen Moduln> <Definition der exportierten Datenobjekte> <Definition der exportierten Prozedur-/Funktionsobjekte> END <Name>. Implementations-Modul IMPLEMENTATION MODULE <Name> <Importliste(n) von anderen Moduln> <Deklaration der lokalen Objekte> <Beschreibung und Initialisierung der - lokalen und - exportierten (siehe DEFINITION MODULE) Objekte> END <Name>. 8

9 Beispiel: Realisierung eines ADT Stack Definitions-Modul (Schnittstelle, Export-Objekte) DEFINITION MODULE Stack; TYPE STACK; (* opaker Typexport *) ElemType = CARDINAL; (* exlizite Angabe des Basistyps *) Konstruktoren PROCEDURE init_stack() : STACK; PROCEDURE push(s : STACK; x : ElemType) : STACK; PROCEDURE pop(s : STACK) : STACK; PROCEDURE top(s : STACK) : ElemType; PROCEDURE is_empty(s : STACK) : BOOLEAN; Operationen END Stack. Implementations-Modul IMPLEMENTATION MODULE Stack; FROM Storage IMPORT ALLOCATE, DEALLOCATE; TYPE STACK = POINTER TO Object; Object = RECORD item : ElemType; next : STACK END; PROCEDURE pop(s : STACK) : STACK; VAR t : STACK; t := s^.next; DISPOSE(s); RETURN t END pop; 9

10 PROCEDURE push(s : STACK; x : ElemType) : STACK; VAR t : STACK; NEW(t); t^.item := x; t^.next := s; RETURN t END push; PROCEDURE top(s : STACK) : ElemType; RETURN s^.item END top; PROCEDURE is_empty(s : STACK) : BOOLEAN; RETURN (s = NIL) END is_empty; PROCEDURE init_stack() : STACK; RETURN NIL END init_stack END Stack. Ende Implementationsmodul 10

11 Aus programmier- und programmtechnischen ist es von Vorteil, wenn die Realisierung von Daten und Operationen verborgen (information hiding) und eingekapselt (data encapsulation) bleibt in einem Modul ( ADT). Auf das Modul kann dann lediglich über die in einer Schnittstelle bereitgestellten Daten- und Prozedur-/Funktionsobjekte zugegriffen werden. Der Vorteil ist, dass mehrere Personen ein Projekt bearbeiten und sich lediglich über die Schnittstellen ihrer Moduln verständigen müssen. Programmtechnisch sind nur Interaktionen zwischen Moduln möglich, was diejenige klare (modulare) Struktur widerspiegelt, die bei der Analyse und Spezifikation des Problems (vor der Implementation) erarbeitet wurde 11