1

Teil IV : Abstrakte Datentypen (ADT)

§ Abstraktion

§ ADT in Modula-2

K. Murmann, H. Neumann, Fakultät für Informatik, Universität Ulm, 2001

1. Abstraktion

• Rekapitulation• Realisation eines Stacks• Idee für ADT-Konzept• ADTs

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

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: aAdditionsschema für arabische ZahlensAdditionsschema für römische Zahlen

Ø Beispiel 2: Zwei Arten der Multiplikation

Ø 123 * 25 = 123 + 123 + .... + 123 = 3075 (25malige Addition)

Ø 123 * 25246615

3075

Die Multiplikation kann auf verschiedene Arten imple-mentiert werden. Ein ADT versteckt die Art und stellt nach aussen nur die Funktionalität zur Verfügung

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:

Konstruktoren:init_stack: { } → stackpush: stack x S → stack

Operationen:pop: stack → stacktop: stack → Sis_empty: stack → BOOLEAN

END

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.

6

Ø Beispiel: Definition eines ADT „Binär-Baum“

DATATYPE Tree(S) sorts

S, Tree

constructors emptytree : {} ---> Tree maketree : Tree × S × Tree ---> Tree

operations left : Tree ---> Tree right : Tree ---> Tree elem : Tree ---> S depth : Tree ---> N nodecount : 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

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

SchnittstelleDefinitionsmodul

Implementie-rungsmodul(verdeckte Info)

öffentlich

privat

8

Ø Definitions-ModulDefinition der Schnittstelle, die das Verhalten eines ADT beschreibt;das bedeutet: Export von Datenobjekten und Prozeduren/Funktionen

Ø Implementations-ModulRealisation 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>

BEGIN<Beschreibung und Initialisierung der

- lokalen und- exportierten (siehe DEFINITION MODULE) Objekte>

END <Name>.

9

Ø Beispiel: Realisierung eines ADT Stack

Ø Definitions-Modul (Schnittstelle, Export-Objekte)

Operationen

Konstruktoren

DEFINITION MODULE Stack;

TYPE STACK; (* opaker Typexport *) ElemType = CARDINAL; (* exlizite Angabe des Basistyps *)

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;

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;

BEGIN t := s^.next; DISPOSE(s); RETURN t

END pop;

10

PROCEDURE push(s : STACK; x : ElemType) : STACK;

VAR t : STACK;

BEGIN NEW(t); t^.item := x; t^.next := s; RETURN t

END push;

PROCEDURE top(s : STACK) : ElemType;

BEGIN RETURN s^.item

END top;

Ende Implementationsmodul

PROCEDURE is_empty(s : STACK) : BOOLEAN;

BEGIN RETURN (s = NIL) END is_empty;

PROCEDURE init_stack() : STACK;

BEGIN RETURN NIL END init_stack

END Stack.

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