listen
Download
Skip this Video
Download Presentation
Listen

Loading in 2 Seconds...

play fullscreen
1 / 90

Listen - PowerPoint PPT Presentation


  • 119 Views
  • Uploaded on

Listen. Klaus Becker 2003. Listen. Ansgar A., Speyer Claudia B., Koblenz Knut B., Neustadt Annett B., Wörrstadt Stefani D., Bad Ems Jochen F., Ludwigshafen ... ... Wieland S., Trier Harald T.-R., Biesdorf. Teil 1. Objektorientierte Modellierung und Implementierung von Listen.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Listen' - lucie


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
listen

Listen

Klaus Becker

2003

listen1
Listen

Ansgar A., Speyer

Claudia B., Koblenz

Knut B., Neustadt

Annett B., Wörrstadt

Stefani D., Bad Ems

Jochen F., Ludwigshafen

...

...

Wieland S., Trier

Harald T.-R., Biesdorf

teil 1
Teil 1

Objektorientierte Modellierung und Implementierung von Listen

was ist eine liste
Was ist eine Liste?

Lisa

Roland

Anna

Gerd

Stefanie

Susanne

Walter

Ulrike

Theo

...

Eine Liste ist eine endliche,beliebig langeFolge von Elementen, in der an jeder Stelle neue Elemente eingefügt oder vorhandene Elemente entfernt werden können.

Bernd

Ziel ist es zunächst, die dynamische Datenstruktur „Liste“ mit Hilfe einer geeigneten Klasse zu implementieren.

objektorientierte repr sentation
Objektorientierte Repräsentation

Lisa

Roland

Anna

Gerd

Stefanie

Susanne

Walter

Ulrike

...

... = Lisa

Bernd

... = Roland

... = Anna

... = Bernd

... = Gerd

...

objektorientierte repr sentation1
Objektorientierte Repräsentation

Die Listenelemente werden mit Hilfe von Objekten beschrieben.

Die Folgenstruktur der Liste wird mit Hilfe von Referenzen aufgebaut.

... = Lisa

... = Roland

... = Anna

... = Bernd

... = Gerd

...

objektorientierte repr sentation2
Objektorientierte Repräsentation

... = Lisa

Knoten

... = Roland

... = Anna

... = Bernd

... = Gerd

...

objektorientierte repr sentation3
Objektorientierte Repräsentation

Spezielle Liste: String-Liste

Verallgemeinerte Liste: Objekt-Liste

klassendiagramm
Klassendiagramm

Spezielle Liste:

Liste

kennt

Knoten

kennt

anfang: Knoten

next: Knoten

inhalt: string

...

...

klassendiagramm1
Klassendiagramm

Verallgemeinerte Liste:

Liste

kennt

Knoten

kennt

anfang: Knoten

next: Knoten

inhalt:

Object

hat

...

...

implementierung
Implementierung

type TKnoten = class private next : TKnoten; inhalt : TObject; public ... end;

type TListe = class private anfang : TKnoten; public ... end;

Liste

Knoten

anfang: Knoten

next: Knoten

inhalt:

Object

...

...

listenoperationen
Listenoperationen

liste.create

Liste

- anfang: Knoten

- count: integer

{ liste: [ ] }

liste.insert(0, Lisa)

+ create

+ getCount: integer

- knotenItems(pos: integer) : Knoten

+ items(pos: integer): Object

+ delete(pos: integer)

+ insert(pos: integer; obj: Object)

{ liste: [Lisa] }

liste.insert(1, Anna)

{ liste: [Lisa; Anna] }

liste.insert(1, Roland)

Hilfsoperation

{ liste: [Lisa; Roland; Anna] }

liste.delete(1)

{ liste: [Lisa; Anna] }

liste.items(1)  Anna

liste.getCount  2

knotenitems spezifikation
knotenItems – Spezifikation

function TListe.knotenItems (pos: integer): TKnoten;

Die Funktion „knotenItems“ bestimmt den i-ten Knoten der Liste, wobei i = pos+1.

liste.knotenItems(2)

liste knotenitems 2 trace
liste.knotenItems(2) – Trace

z := 0; k := anfang;

liste knotenitems 2 trace1
liste.knotenItems(2) – Trace

inc(z); k := k.getNext;

liste knotenitems 2 trace2
liste.knotenItems(2) – Trace

inc(z); k := k.getNext;

knotenitems algorithmus
knotenItems – Algorithmus

begin

z := 0;

k := anfang;

while ((z < pos) and (z < count)) do

begin

inc(z);

k := k.getNext;

end;

result := k;

end;

items spezifikation
items – Spezifikation

function TListe.items (pos: integer): TObject;

Die Funktion „items“ bestimmt den Inhalt des i-ten Knotens der Liste, wobei i = pos+1.

liste.items(2)

items algorithmus
items – Algorithmus

function TListe.items (pos: integer): TObject;

begin

if ((pos >= 0) and (pos < count)) then

result := knotenItems(pos).getInhalt

else

result := nil;

end;

delete spezifikation
delete – Spezifikation

procedure TListe.delete(pos: integer);

liste.delete(2)

liste delete 2 trace
liste.delete(2) – Trace

hilf := knotenItems(pos);

liste delete 2 trace1
liste.delete(2) – Trace

knotenItems(pos-1). setNext(knotenItems(pos).getNext);

liste delete 2 trace2
liste.delete(2) – Trace

hilf.getInhalt.free; hilf.free;dec(count)

achtung liste delete 0
Achtung: liste.delete(0)

knotenItems(pos-1). setNext(knotenItems(pos).getNext);

achtung liste delete 01
Achtung: liste.delete(0)

anfang := knotenItems(pos).getNext

insert spezifikation
insert – Spezifikation

procedure TListe.insert (pos: integer; obj: TObject);

liste.insert(2,o)

liste insert 2 o trace
liste.insert(2,o) – Trace

danach := knotenItems(pos);

liste insert 2 o trace1
liste.insert(2,o) – Trace

neu := TKnoten.create(danach,obj);

liste insert 2 o trace2
liste.insert(2,o) – Trace

knotenItems(pos-1).setNext(neu);inc(count);

vorsicht liste insert 0 o
Vorsicht: liste.insert(0,o)

knotenItems(pos-1).setNext(neu);

aufgabe
Aufgabe

Entwickeln Sie mit Hilfe der Trace-Beispiele die Algorithmen zu den beiden Operationen delete und insert.

Erstellen Sie ein neues Delphi-Projekt (in einem neuen Ordner) und implementieren Sie die Klasse TListe.

l sung delete algorithmus
Lösung: delete – Algorithmus

procedure TListe.delete(pos: integer); var hilf: TKnoten;beginif pos <= count-1 then begin hilf := knotenItems(pos); if pos = 0 then anfang := knotenItems(pos).getNext else knotenItems(pos-1).setNext(knotenItems(pos).getNext); hilf.getInhalt.free; hilf.free; dec(count); end;end;

l sung insert algorithmus
Lösung: insert – Algorithmus

procedure TListe.insert (pos: integer; obj: TObject); var neu, danach: TKnoten;beginif pos <= count then begin if pos = 0 then begin danach := anfang; neu := TKnoten.create(danach, obj); anfang := neu; inc(count); end else begin danach := knotenItems(pos); neu := TKnoten.create(danach, obj); knotenItems(pos-1).setNext(neu); inc(count); end; end;end;

listentest
Listentest

Ziel ist es, ein Programm zu erstellen, mit dessen Hilfe die Implementierung der Klasse „TListe“ gestestet werden kann.

Z. B.: Es soll eine Namensliste [Lisa; Anna; ...] erstellt und angezeigt werden.

spezialisierung
Spezialisierung

Allgemeine Liste:

Spezialisierte Liste:

spezialisierung1
Spezialisierung

Liste

kennt

Knoten

Object

kennt

anfang: Knoten

next: Knoten

inhalt:

ist

...

hat

...

Element

wert: String

create(w: String)setWert(w: String)getWert: String

erzeugung einer liste
Erzeugung einer Liste

liste := TListe.create;

e := TElement.create(\'Lisa\');

liste.insert(0,e);

e := TElement.create(\'Anna\');

liste.insert(1,e);

...

anzeige einer liste
Anzeige einer Liste

Hilfsvariable

h := \'\';

for i := 0 to liste.getCount-1 do

begin

w := TElement(liste.items(i)).getWert;

h := h + \' \' + w;

end;

PListe.Caption := h;

Typumwandlung: TObject  TElement

Anzeige-Panel

aufgabe1
Aufgabe

Die Klasse „TElement“ ist noch nicht implementiert. Ergänzen Sie die fehlenden Teile.

Erstellen Sie eine einfache Testoberfläche und ergänzen Sie die Methodenaufrufe zur Erzeugung und zur Anzeige einer Testliste

Zur Kontrolle: Listen2

teil 2
Teil 2

Anwendung: Lexikon

auftrag
Auftrag

Ziel ist es, ein Programm zur Erstellung und Benutzung eines Glossars (Lexikons) zu entwickeln.

Aus: H. Balzert: Lehrbuch Grundlagen der Informatik, S. 137.

pflichtenheft
Pflichtenheft

/0/ Das Lexikon ist eine endliche Folge von Einträgen. Jeder Eintrag liefert eine Erläuterung zu einem Stichwort.

/1/ Im Lexikon kann der Benutzer eine Erklärung zu einem Stichwort nachschlagen. Der Benutzer muss hierzu das ihn interessierende Stichwort eingeben.

/2/ Das Lexikon kann vom Benutzer ergänzt und verändert werden: Es können jederzeit neue Einträge eingefügt und bereits bestehende Einträge gelöscht werden.

/3/ Das Lexikon kann extern gespeichert und wieder geladen werden.

slide47
OOA

Ein Lexikon ist eine endliche Folge von Einträgen. Jeder Eintrag liefert eine Erläuterung zu einem Stichwort.

Im Lexikon kann man eine Erklärung zu einem Stichwort nachschlagen.

Das Lexikon kann ergänzt und verändert werden: Es können neue Einträge eingefügt und bereits bestehende Einträge gelöscht werden.

Das Lexikon kann extern gespeichert und wieder geladen werden.

slide48
OOD

„create“ erstellt ein neues Listenobjekt „liste“.

„addEintrag“ erstellt zunächst ein „Eintrag“-Objekt und fügt es dann in „liste“ ein.

„delEintrag“ durchsucht zunächst die Liste „liste“ nach dem „stichwort“ und bestimmt gegebenenfalls die Position. Anschließend wird der zugehörige Eintrag in der Liste gelöscht.

„getErlaeuterung“ liefert zu dem „stichwort“ die zugehörige Erläuterung im Lexikon.

algorithmen
Algorithmen

constructor TLexikon.create;beginliste := TListe.create(nil); end;

procedure TLexikon.addEintrag(stichwort, erlaeuterung: string); var eintrag: TEintrag;begineintrag := TEintrag.create(stichwort,erlaeuterung);liste.insert(0,eintrag); end;

algorithmen1
Algorithmen

procedure TLexikon.delEintrag(stichwort: string); var i, position: integer;beginposition := -1;for i := 0 to liste.getCount-1 do if TEintrag(liste.items(i)).getStichwort = stichwort then position := i; if position >= 0 then liste.delete(position); end;

algorithmen2
Algorithmen

function TLexikon.getErlaeuterung(stichwort: string): string; var position: integer; erlaeuterung: string;beginerlaeuterung := \'kein Eintrag gefunden!\';for position := 0 to liste.getCount-1 do if TEintrag(liste.items(position)).getStichwort = stichwort then erlaeuterung := TEintrag(liste.items(position)).getErlaeuterung;result := erlaeuterung;end;

aufgabe2
Aufgabe

Delphi verfügt über eine vordefinierte Klasse „TList“. Informieren Sie sich über diese Klasse mit der Delphi-Hilfe. Implementieren Sie dann das Lexikon mit dieser vordefinierten Klasse „TList“ an Stelle der selbst entwickelten Klasse „TListe“.

Zur Kontrolle: siehe Lexikon2

zum vergleich
Zum Vergleich

Vordefinierte Liste

Selbstdefinierte Liste

unit uLexikon;interfaceuses uEintrag, uListe {TListe};type TLexikon = class privateliste: TListe; public constructor create; ... end;

unit uLexikon;interfaceuses uEintrag, classes {TList};type TLexikon = class privateliste: TList; public constructor create; ... end;

zum vergleich1
Zum Vergleich

Vordefinierte Liste

Selbstdefinierte Liste

constructor TLexikon.create;beginliste := TListe.create; // liste := TList.create;end;

zum vergleich2
Zum Vergleich

Vordefinierte Liste

Selbstdefinierte Liste

procedure TLexikon.addEintrag(stichwort, erlaeuterung: string); var eintrag: TEintrag;begineintrag := TEintrag.create(stichwort,erlaeuterung);liste.insert(0,eintrag); // liste.Insert(0, eintrag);end;

zum vergleich3
Zum Vergleich

Vordefinierte Liste

Selbstdefinierte Liste

procedure TLexikon.delEintrag(stichwort: string); var i, position: integer;beginposition := -1;for i := 0 to liste.getCount-1 do // liste.Count-1 if TEintrag(liste.items(i)).getStichwort = stichwort then position := i; // liste.Items[i]if position >= 0 then liste.delete(position); // liste.Delete(position)end;

zum vergleich4
Zum Vergleich

Vordefinierte Liste

Selbstdefinierte Liste

function TLexikon.getErlaeuterung(stichwort: string): string; var position: integer; erlaeuterung: string;beginerlaeuterung := \'kein Eintrag gefunden!\';for position := 0 to liste.getCount-1 do // liste.Count-1 if TEintrag(liste.items(position)).getStichwort = stichwort then erlaeuterung := TEintrag(liste.items(position)).getErlaeuterung;result := erlaeuterung;end; // liste.Items[position]

zum vergleich5
Zum Vergleich

Properties

TListe

TList

- anfang: Knoten

- count: integer

+ Count: integer+ Items[pos: integer]: Pointer

+ create(k: Knoten)

+ getCount: integer

- knotenItems(pos: integer) : Knoten

+ items(pos: integer): TObject

+ delete(pos: integer)

+ insert(pos: integer; obj: TObject)

+ create

+ Delete(pos: integer)

+ Insert(pos: integer; obj: Pointer)...

teil 3
Teil 3

Stapel und Schlangen

auswertung von termen
Auswertung von Termen

Term:

( 7 - 2 ) * 3 =

7

-

2

)

2

-

-

(

7

(

7

(

7

(

*

3

=

3

5

5

*

5

*

15

Operatorenstapel

Operandenstapel

stapel
Stapel

mitErstem

erstes

ohneErstes

LIFO-Prinzip: last in, first out

modellierung
Modellierung

mitErstem

erstes

ohneErstes

Stapel

+ create

+ istLeer: boolean

+ mitErstem(obj: Object)

+ erstes: Object

+ ohneErstes

druckerwarteschlange
Druckerwarteschlange

Druckauftragswarteschlange

schlange
Schlange

mitLetztem

erstes

ohneErstes

FIFO-Prinzip: first in, first out

modellierung1
Modellierung

mitLetztem

erstes

ohneErstes

Schlange

+ create

+ istLeer: boolean

+ mitLetztem(obj: Object)

+ erstes: Object

+ ohneErstes

vereinfachung
Vereinfachung

Im folgenden sollen nur Stapel und Schlangen betrachtet werden, deren Elemente Zeichenketten sind.

Stapel

Schlange

+ create

+ istLeer: boolean

+ mitErstem(s: String)

+ erstes: String

+ ohneErstes

+ create

+ istLeer: boolean

+ mitLetztem (s: String)

+ erstes: String

+ ohneErstes

implementierung1
Implementierung

unit uStapel;

interface

uses classes {TStringList};

type

TStapel = class(TStringList) private public constructor create; function istLeer: boolean; procedure mitErstem(s: string); procedure ohneErstes; function erstes: string; end;

implementation

...

TStringList

+ Count: integer

+ Strings: array[0..] of string

+ create

+ delete(p: integer)

+ insert(p: integer; s: String)

...

Stapel

+ create

+ istLeer: boolean

+ mitErstem(s: String)

+ erstes: String

+ ohneErstes

implementierung2
Implementierung

constructor TStapel.create;begin inherited create; end;

function TStapel.istLeer: boolean;begin result := (Count = 0); end;

function TStapel.erstes: string;begin result := Strings[0]; end;

procedure TStapel.ohneErstes;begin delete(0); end;

procedure TStapel.mitErstem(s: string);begin insert(0,s); end;

TStringList

+ Count: integer

+ Strings: array[0..] of string

+ create

+ delete(p: integer)

+ insert(p: integer; s: String)

...

Stapel

+ create

+ istLeer: boolean

+ mitErstem(s: String)

+ erstes: String

+ ohneErstes

aufgabe3
Aufgabe

Implementieren Sie analog die Klasse Schlange. Benutzen Sie hierzu die vordefinierte Delphi-Klasse TStringList. Die benötigten Attribute (Properties) und Operationen sind im nebenstehenden Klassendiagramm aufgeführt. Die Bedeutung der Bestandteile kann mit der Delphi-Hilfe ermittelt werden.

Erstellen Sie auch (einfache) Testprogramme, um die Korrektheit der Operationen zu überprüfen.

TStringList

+ Count: integer

+ Strings: array[0..] of string

+ create

+ delete(p: integer)

+ insert(p: integer; s: String)

...

Schlange

+ create

+ istLeer: boolean

+ mitLetztem (s: String)

+ erstes: String

+ ohneErstes

teil 4
Teil 4

Anwendung: Taschenrechner

auftrag1
Auftrag

Es soll ein Demo-Taschenrechner erstellt werden, der die Bearbeitung von Klammertermen veranschaulicht.

Eingabe:

( 7 - 2 ) * 3 =

Verarbeitung:

7

-

2

)

2

-

-

(

7

(

7

(

7

(

Ergebnis: (7 - 2) * 3 = 15

pflichtenheft1
Pflichtenheft

/0/ Der Benutzer gibt die Bestandteile des Terms – auch Token genannt – Schritt für Schritt ein: Klammern, Zahlen, Rechenzeichen (+, -, *, :), Gleicheitszeichen. Z.B.: ( 7 - 2 ) * 3 =

/1/ Die Bearbeitung des Terms wird Schritt für Schritt mit Hilfe eines Buttons ausgelöst. Die benutzten Stapel werden dabei jeweils auf dem Bildschirm angezeigt.

/2/ Der gesamte Term und das berechnete Ergebnis wird abschließend angezeigt.

auswertung von termen1
Auswertung von Termen

Term:

( 7 - 2 ) * 3 =

7

-

2

)

2

-

-

(

7

(

7

(

7

(

*

3

=

3

5

5

*

5

*

15

interpreter
Interpreter

) * 3 =

termSchlange

operandenStapel

operatorenStapel

2

-

7

(

\'(7-2\'

\'\'

Interpreter

slide76
OOM

) * 3 =

termSchlange

operandenStapel

operatorenStapel

2

+

7

(

\'(7-2)\'

\'\'

Interpreter

aufgabe4
Aufgabe

Ergänzen Sie den Interpretieralgorithmus.

Fall 1: Das erste Element der TermSchlange ist ein Gleichheitszeichen und der OperatorenStapel ist nicht leer:

=

2

7

-

\'7-2\'

\'\'

aufgabe5
Aufgabe

Ergänzen Sie den Interpretieralgorithmus.

Fall 2: Das erste Element der TermSchlange ist ein Gleichheitszeichen und der OperatorenStapel ist leer:

=

5

\'(7-2)\'

\'\'

aufgabe6
Aufgabe

Ergänzen Sie den Interpretieralgorithmus.

Fall 3: Das erste Element der TermSchlange ist „Klammerauf“:

( 7 - 2 ) =

\'\'

\'\'

aufgabe7
Aufgabe

Ergänzen Sie den Interpretieralgorithmus.

Fall 4: Das erste Element der TermSchlange ist „Klammerzu“:

) =

2

-

7

(

\'(7-2\'

\'\'

aufgabe8
Aufgabe

Ergänzen Sie den Interpretieralgorithmus.

Fall 5: Das erste Element der TermSchlange ist ein Rechenzeichen:

- 2 ) =

7

(

\'(7\'

\'\'

aufgabe9
Aufgabe

Ergänzen Sie den Interpretieralgorithmus.

Fall 6: Das erste Element der TermSchlange ist eine Zahl:

2 ) =

-

7

(

\'(7-\'

\'\'

aufgabe10
Aufgabe

Implementieren Sie den Interpreter und testen Sie das Taschenrechner-Programm.

Welche Erweiterungen wären wünschenswert?

l sung
Lösung

Fall 1: Das erste Element der TermSchlange ist ein Gleichheitszeichen und der OperatorenStapel ist nicht leer:

hilf := termSchlange.erstes;termSchlange.ohneErstes;term := term + hilf;z1 := StrToInt(operandenStapel.erstes);operandenStapel.ohneErstes;z2 := StrToInt(operandenStapel.erstes);operandenStapel.ohneErstes;op := operatorenStapel.erstes;operatorenStapel.ohneErstes;if (op = \'+\') then erg := z2 + z1;if (op = \'-\') then erg := z2 - z1;if (op = \'*\') then erg := z2 * z1;if (op = \':\') then erg := z2 div z1;ergebnis := IntToStr(erg);operandenStapel.mitErstem(ergebnis);

=

2

7

-

\'7-2\'

\'\'

l sung1
Lösung

Fall 2: Das erste Element der TermSchlange ist ein Gleichheitszeichen und der OperatorenStapel ist leer:

hilf := termSchlange.erstes;termSchlange.ohneErstes;term := term + hilf;ergebnis := operandenStapel.erstes;

=

5

\'(7-2)\'

\'\'

l sung2
Lösung

Fall 3: Das erste Element der TermSchlange ist „Klammerauf“:

hilf := termSchlange.erstes;termSchlange.ohneErstes;term := term + hilf;token := hilf;operatorenStapel.mitErstem(token);

( 7 - 2 ) =

\'\'

\'\'

l sung3
Lösung

Fall 4: Das erste Element der TermSchlange ist „Klammerzu“:

hilf := termSchlange.erstes;termSchlange.ohneErstes;term := term + hilf;z1 := StrToInt(operandenStapel.erstes);operandenStapel.ohneErstes;z2 := StrToInt(operandenStapel.erstes);operandenStapel.ohneErstes;op := operatorenStapel.erstes;operatorenStapel.ohneErstes;operatorenStapel.ohneErstes;if (op = \'+\') then erg := z2 + z1;if (op = \'-\') then erg := z2 - z1;if (op = \'*\') then erg := z2 * z1;if (op = \':\') then erg := z2 div z1;token := IntToStr(erg);operandenStapel.mitErstem(token);

) =

2

-

7

(

\'(7-2\'

\'\'

l sung4
Lösung

Fall 5: Das erste Element der TermSchlange ist ein Rechenzeichen:

hilf := termSchlange.erstes;termSchlange.ohneErstes;term := term + hilf;token := hilf;operatorenStapel.mitErstem(token);

- 2 ) =

7

(

\'(7\'

\'\'

l sung5
Lösung

Fall 6: Das erste Element der TermSchlange ist eine Zahl:

hilf := termSchlange.erstes;termSchlange.ohneErstes;term := term + hilf;token := hilf;operandenStapel.mitErstem(token);

2 ) =

-

7

(

\'(7-\'

\'\'

literaturhinweise
Literaturhinweise

Helmut Balzert: Lehrbuch Grundlagen der Informatik. Spektrum Ak. Verlag 1999.

H.-P. Gumm u. M. Sommer: Einführung in die Informatik. Oldenbourg Verlag 2002.

...

ad