2.3 Implementierung und Anwendung von ADT Anwendung von ADT... am Beispiel "Stapel"

Transkript

1 2.3 Implementierung und Anwendung von ADT Anwendung von ADT. am Beispiel "Stapel" Ziel Implementierung einer Anwendung ohne Annahmen über die Implementierung der Typen Austauschen der Implementierung eines ADT ohne Veränderung des Klientenprogramms. Auswertung Arithmetischer Ausdrücke: Wichtige Anwendung von Stapeln Auswerten von arithmetischem Ausdruck Definition arithmetischer Ausdrücke ( infix-notation von zweistelligen Operationen) eine reelle Zahl ist ein AA von a und b AA, dann auch a+b, a-b, a*b, a/b, und (b) das sind alle AA Auswertung nach Operatorpräferenz (hier: " Punkt vor Strich") Auswertungsmethode: - Ausdruck in umgekehrter polnischer Notation - Einkellern von Operanden und Zwischenergebnissen hs / fub alp3 ADT-3 2 1

2 Polnische Notation Klammerfreie Schreibweise von arithmetischen Ausdrücken Operatoren stehen vor den Operanden (Jan Lukasiewicz, polnischer Logiker, , ) Beispiel: (2+3) * 5 -> * Auswertung: Operatoranwendung wenn genügend Operanden vorhanden. Alternative: Umgekehrte polnische Notation ("reverse polish notation", "postfix") * hs / fub alp3 ADT-3 3 Auswertung klammerfreier Ausdrücke Beispiel: (5+3) *(9-4) / > * 5 / * / hs / fub alp3 ADT-3 4 2

3 Auswertung klammerfreier Ausdrücke Algorithmus (Pseudocode, no Syntax check) : double eval (String a) { Stack s = new Stack(); while (not a.stringempty()) { token a = readnext(); // reads number or token if (isnumber(a)) s.push(); else {right = s.top(); s.pop(); // a is operator left = s.top(); s.pop(); s.push(execop( left,a,right)) return s.top(); hs / fub alp3 ADT-3 5 "Infix to postfix" Infix Darstellung von arithmetischen Ausdrücken binäre Operatoren zwischen Operanden ggf. Klammerung * 5 / 10 ((2+3)*5 +1) / 2 Postfix Darstellung Operatoren stehen "geeignet" hinter den Operanden keine Klammern nötig Achtung: wird 5 + (3*(10/5)) ausgewertet! entspricht nicht der / * + Konvention "Linksklammerung". siehe separate Anmerkungen * / hs / fub alp3 ADT-3 6 3

4 "Infix to postfix" " mit Hilfe eines Operator-Stapel Input: 2 * 3 4 / 2 Output _ Stack _ * 3 4 / / 2 2 * -4/ 2 23 * 4 / * - / 2 2 3* 4 - / *4 2 - / 2 3 * 4 2 / Wichtig: Operatorpräferenz hs / fub alp3 ADT-3 7 Operatorpräferenzen stack 2+3 * 5 -> // Lesen von * : pref * > pref (top) * // push * Ergebnis: * + 2* > 2 3 * 2 3 * + // Lesen von + : pref + < pref (top) Ergebnis: 2 3 * 5 + _ // Pop bis Operator kleiner Präfer. // "top-of-stack" (2+3) * 5 -> 2 3 (+ // Öffnende Klammer auf Stapel * _ // Schließende Klammer: pop bis "(" Ergebnis: * hs / fub alp3 ADT-3 8 4

5 Assoziativität von Operatoren Was ist 30 / 5 / 2? Konvention: 30 / 5 / 2 = ( (30 / 5) / 2) Taucht das zweite "/" auf, ist das erste abgearbeitet => pop => 30 5 / 2 / ausgewertet: 3 op linksassoziativ a op b op c = (a op b) op c op rechtsassoziativ a op b op c = a op (b op c) Beispiel: Potenz a^b ^c = (a ^(b ^ c) ) hs / fub alp3 ADT-3 9 "Infix -> > Präfix" - Algorithmus String infix2postfix (String a) { Stack s = new Stack(); StringBuffer result = new StringBuffer(); while (not a.stringempty()) { token a = readnext(); // reads number or token if (isnumber(a)) result.append(a); else {if (a="(" ) s.push(a); if (pref (a) > pref(s.top()) s.push(a); if (pref (a < pref(s.top()) popandappend(s,result); if (pref (a) = pref(s.top() & isrightass(a) ) s.push(a);. isleftass() ).. return result.tostring( ); hs / fub alp3 ADT

6 Repräsentation von Präferenzen Zwei Präferenzen für jeden Operator: Zeichen EingabePräf. Stapelpräferenz ( ) 0 99 * 3 4 / Höhere Stapel- als Eingabepräferenz : Linksassoziativität sonst rechtsassoziativ. Beipiel: 3 * 4 / 6 -> 3 4 * 6 / hs / fub alp3 ADT-3 11 Programmentwurf Naiv: Main eval PostFixEval push, pop,.. Nachteile: - als Reimplementierung des (Object) Stack! - EINE Implementierung, Änderung erzwingt Änderung des Klienten (PostFixEval). hs / fub alp3 ADT

7 class PostFixEval { ds = new (); class { // hier werden alle Stackoperationen nacherfunden! Programmentwurf Lösung des ersten Teilproblems: Adapterpattern Main eval PostFixEval pushd(),.. topandpop() «interface» MyStackImp push(), pop(),.. Besser: Keine Reimplementierung sondern Nutzung von Stack-Operationen hs / fub alp3 ADT

8 class implements IF{ MyStackImpl s = new MyStackImpl(); class MyStackImpl { // Implementierung // aber Datenabstraktion mit ADT?? hs / fub alp3 ADT-3 15 Programmentwurf Main eval PostFixEval pushd(),.. topandpop() «interface» Entkoppelung von Schnittstelle und Implementierung: Klient von class Stack kennt nur Schnittstelle. «interface» Stack ArrayStack push(), pop(),.. hs / fub alp3 ADT

9 class implements IF{ protected Stack s = new ArrayStack (); interface Stack { public void push(){.. Was wenn mehr als eine Stackimplementierung? class ArrayStack implements Stack { // Implementierung // aber Datenabstraktion mit ADT?? Mehrere Implementierungen Main eval PostFixEval pushd(),.. topandpop() «interface» Entkoppelung von Schnittstelle und Implementierung: Klient von class Stack kennt nur Schnittstelle. «interface» Stack push(), pop(),.. ArrayStack LListStack hs / fub alp3 ADT

10 Programmentwurf: Objektfabrik class implements IF{ protected Stack s = new ArrayStack(); LListStack() Idee: Keine direkte Verwendung von Konstruktoren der implementierenden Klassen. Stattdessen Klasse zur Objekterzeugung (Objektfabrik) mit einheitlicher Schnittstelle, z.b. public Stack getstack() hs / fub alp3 ADT-3 19 Programmentwurf: Objektfabrik Main eval PostFixEval pushd(),.. topandpop() «interface» «interface» Stack new StackFactory getstack() push(),.. pop() ArrayStack LListStack StackFactory ist zu ändern, wenn andere Stack-Implementierung verwendet werden soll hs / fub alp3 ADT

11 Nutzung der Objektfabrik class implements IF{ protected Stack s = (new StackFactory().getStack()); public class StackFactory { protected final int ARRAYSTACK = 1; // zum Beispiel protected final int LLISTSTACK = 2; int whichone = ARRAYSTACK; public StackFactory(int which) {whichone = which; public Stack getstack() { if (whichone = ARRAYSTACK) return (new StackArray()); if (whichone = LLISTSTACK) return (new LListArray()); hs / fub alp3 ADT-3 21 Vereinfachung: statische Fabrikmethode Main eval PostFixEval pushd(),.. topandpop() «interface» abstract Stack new getstack() push(),.. pop() static getstack() ArrayStack LListStack statische Factory Methode ist zu ändern, wenn andere Stack- Implementierung verwendet werden soll hs / fub alp3 ADT

12 Vereinfachung: statische Fabrikmethode class implements IF{ protected Stack s = Stack.getStack()); abstract class Stack {.. public abstract void pop() throws Underflow;;. public static Stack getstack(){ return (new StackArray()); // or which kind of stack implementation // you want hs / fub alp3 ADT