Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 31 Grundgebiete der Informatik 2: Algorithmen und.

Präsentation zum Thema: "Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 31 Grundgebiete der Informatik 2: Algorithmen und."—  Präsentation transkript:

1 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 31 Grundgebiete der Informatik 2: Algorithmen und Programmiertechniken Tutorium zur Klausurvorbereitung

2 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 32 EBNF Gibt mögliche Programmstruktur vor Darstellungsform für kontextfreie Grammatiken Äquivalent zu Syntaxdiagrammen Sequenz, Option [ ], Wiederholung { }, Alternative |, Rekursion Nichtterminal- Symbol Terminal- Symbol Metasymbole der EBNF factor ::= number | ident | ( expression ) | ! factor Rekursion number ident expression factor () !

3 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 33 Ableiten eines Worts aus einer EBNF Wort: Folge von Terminalsymbolen, die durch Anwendung von Regeln einer Grammatik/EBNF erzeugt wurde Beispiel bezieht sich auf EBNF aus Aufgabe 1 if ( a + b == !c) { cout << "test"; } if ( expression ) { statementList } 2 6 if ( simpleExpression relation simpleExpression ) { statement } 4 3 4 8 if ( factor addOperator factor == factor) { cout << string; } 5 7 5 5 if (ident + ident == ! factor ) { cout << string; } 5 if (ident + ident == ! ident) { cout << string; } 1

4 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 34 Ebenen der Syntax & Semantik Lexikalische Syntax: Schlüsselwörter, Bezeichner, Literale, Begrenzer,... Kontextfreie Syntax (Aufbausyntax): Beschreibt Aufbau eines Programms Ausdrücke, Anweisungen, Deklarationen, Programmstruktur Kontextsensitive Syntax: Beschreibt Beziehungen zwischen Teilen eines Programms Semantik: Beschreibt die Bedeutung der Elemente, aus denen ein Programm aufgebaut ist EBNF Umgangs- sprachlich Umgangs- sprachlich

5 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 35 Beispiel für Ebenen der Syntax Ausdrücke Deklarationen Anweisungen Programmstruktur Kontextfreie Syntax #include int summiere(int a, int b) { return a + b ; } int main() { int a, b, summe ; cin >> a >> b; summe = summiere(a,b); cout << summe << endl; } Kontextsensitive Syntax Zur Deklaration Lexikalische Syntax Literale: 1.8e6 ; `` Hallo `` Schlüsselworte: int, return Bezeichner: summiere, a, b Begrenzer: ; { } ( ) space tab Kommentare: Eine lexikalische Einheit, die aber ignoriert wird

6 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 36 Alte Klausuraufgabe 1 #include "iostream" 2 using namespace std; 3 4 void StraightInsertion(char ffeld[], int start, int ende) { 5 int j; 6 char elem 7 8 for (int i=start+1; i<=ende, i++) { 9 // aktuelles Element merken 10 elem=ffeld[k]; 11 /* an der richtigen Stelle in 12 den bereits sortierten Anfang 13 Einfuegen */ 14 j=i; 15 while ((j>start) & (elem<ffeld[j-1]) { 16 ffeld[j] = ffeld[j-1]; 17 j--; 18 } 19 ffeld[j] = elem; 20 } 21 }

7 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 37 Alte Klausuraufgabe 4 void StraightInsertion(char ffeld[], int start, int ende){ … 21 } 22 23 int main() 24 { 25 char feld[] ={ 'v', k, 'a', 'h', 'j', 'l', 'e', 'b'}; 26 StraightInsertion(*feld, 0, 7); 27 for (int i=0;i<8;i++) { 28 cout << feld[i] << ' '; 29 } 30 return 0; 31 }

8 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 38 Kontrollstrukturen Fallunterscheidungen if ( zahl > 0 ) { // Anweisungsfolge } if ( zahl > 0 ) { // Anweisungsfolge } else { // Alternative A. } Einseitig bedingte Anweisung Zweiseitig bedingte Anweisung

9 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 39 Kontrollstrukturen Auswahlanweisung enum Wochentag { Mo, Di, Mi, Do, Fr, Sa, So }; Wochentag Tag; switch ( Tag ) { case Mo: // Anweisungen break; case Di: case Mi: // Anweisungen break; default: // Anweisungen break; } Fall „Mo“ Fälle ‚ „ Di “ und „ Mi “ Alle anderen Fälle (optional)

10 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 310 Kontrollstrukturen Schleifen –Wiederholte Ausführung einer Anweisungsfolge (Block) –Unterscheidung Anzahl der Iterationen bekannt  for -Schleife // Berechnung der Fakultät int eingabe, fakultaet = 1; cin >> eingabe; for ( int i=1; i < eingabe; i++ ) { fakultaet *= i; } Anzahl der Iterationen unbekannt  while -Schleife // Reaktion auf Messfuehler while ( Messfuehler.GibWert() > 0 ) { cout << "Aktueller Wert: " << Messfuehler.GibWert() << endl; } cout << "Wert ist nicht mehr positiv!" << endl;

11 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 311 Prozedur vs. Funktion vs. Methode Prozedur –Führt eine Anweisungsfolge aus –Basiert auf Parametern, verändert diese gegebenenfalls –Kein Rückgabewert –Beenden der Prozedur durch return ; (optional) void Ausgabe( int a ) { cout << a << endl; } Funktion –Wie Prozedur, aber: –Hat Rückgabewert ungleich void –Beenden der Funktion & Rückgabe durch return -Anweisung int Eingabe() { int eingabe;// Auf Groß-/Kleinschreibung achten! cin >> eingabe; return eingabe; } Methode –Gehört zu einer Klasse (bspw. ADT) "member function" –Kann Prozedur oder Funktion sein –Durch Klassenzugehörigkeit: Zugriff auf private Klassen-Elemente

12 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 312 Variablen, Pointer, Referenzen Prinzipiell varTyp varBezeichner; Pointer –Deklaration: Vor jedem Var.-Bezeichner * Referenzen –Deklaration: Vor jedem Var.-Bezeichner & –Muss direkt initialisiert werden Dereferenzierung: * "Folgt dem Zeiger" Adresse von: & "Liefert Zeiger auf" int a;// Integer-Variable, Name:"a" int *pa;// Pointer/Zeiger auf Integer-Variable int &ra = a;// Referenz auf Integer-Variable pa = &a; // Pointer "pa" zeigt nun auf "a" a = 10; cout << a; *pa = 20; cout << a; ra = 30; cout << a;

13 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 313 #include "iostream.h" void f(int &x, int y, int *z) { y++; x=*z+y; x++; ++(*z); } int main() { int a=1, b=2, c=3; f(a, b, &c); //1. Aufruf cout << "1. Aufruf: " << a << b << c << char(13) << char(10); f(a, b, &c); //2. Aufruf cout << "2. Aufruf: " << a << b << c << char(13) << char(10); return 0; } Parameterübergabe: Beispiel Call by Value Call by Reference abc vor 1. Aufruf123 nach 1. Aufruf724 nach 2. Aufruf825

14 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 314 Datentypen: vordefinierte, Typdeklaration Vordefinierte Typen (Beispiele): [unsigned] int, char, [unsigned] double,double dbl; short, float,... Arrays: int i[41];int *i[41]; Typdeklaration: typedef int *pIntT; Verwendung: pIntT pi; Objekt- deklarationen Objekt- deklaration

15 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 315 Datentypen: Arrays, Strukturen,... Aufzählungstypen [typedef] enum Werktag {di, mi}; Arrays typedef int* IntPtrFeld[41]; Strukturen [typedef] struct MyStruct { int i; MyStruct* next; }; Verwendung MyStruct aStruct; IntPtrFeld anArray; Typ- deklaration Objekt- deklarationen

16 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 316 Datentypen: komplexes Beispiel struct MyStruct { int i; SomeType* info; }; typedef MyStruct ComplexArray[7]; ComplexArray anArray; 1 27 3 8 5 22 53

17 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 317 Speicherallokation und Freigabe Speicher auf dem Heap allokieren: Allokierten Speicher wieder freigeben: int* iPtr; iPtr=new int; *iPtr=42;... delete iPtr; iPtr=NULL; iPtr

18 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 318 Datentypen: Zugriff auf Strukturkomponenten struct MyStruct { int i; MyStruct* next; }; MyStruct s; MyStruct *ps; ps=&s; s.i=9; (*ps).i=9; ps->i=9; s->i=9; //falsch ps.i=9; //falsch

19 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 319 Datenstrukturen: Verkettete Liste head Laufzeiger 9 3 77122 struct lElemT{ int value; lElemT *next; }; lElemT* head;... head=NULL; head 9 3 77122 37 z.B. Element einfügen // z: Einfuegestelle lElemT *newElem=new lElemT; newElem->value=37; newElem->next=z->next; z->next=newElem; newElem z

20 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 320 Graphrealisierungen knotenorientiert –Adjazenzlisten = Liste von Knoten, jeder Knoten hat Liste seiner Nachfolger sequentiell verkettet –charakteristische Adjazenzmatrix = Matrix, Knoten in Zeilen- und Spaltenüberschriften, Kantengewichte bzw. 1/0 in Zellen kantenorientiert –Kantenlisten sequentiell verkettet –charakteristische Inzidenzmatrix = Knoten in Zeilenüberschriften, Kanten in Spaltenüberschriften 1 2 3 11 1 1 2 3 123 1 11 1 2 3 123 1 2 3 112 233 123 1 2 3 23 3

21 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 321 Sortierenalgorithmen

22 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 322 Aufwandsabschätzung in O-Notation O-Notation –Gibt Größenordnung an –Abstrahiert von "unwichtigen" Details/Faktoren –Oft Abschätzung für besten, mittleren und schlechtesten Fall z.B.: Quadratischer Aufwand: Logarithmischer Aufwand: Linearer Aufwand Konstanter Aufwand     a·log(n)+cO(log(n))

23 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 323 Sortierverfahren (1) Sortieren durch Einfügen (Straight Insertion) sortiert Bubblesort sortiert "Größte Blase steigt auf" Bester Fall: O(n) Mittlerer Fall: O(n²) Schlechtester Fall: O(n²) Bester Fall: O(n) Mittlerer Fall: O(n²) Schlechtester Fall: O(n²)

24 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 324 Sortierverfahren (2) Quicksort Bester Fall: O(n log 2 n) Mittlerer Fall: O(n log 2 n) Schlechtester Fall: O(n²) a <a aa Rekursion!

25 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 325 Suchverfahren Lineare Suche: –Laufe von vorne nach hinten bis Element gefunden Binäre Suche: –Sortierung vorausgesetzt ! –vergleiche mit mittlerem Element: gleich: gefunden kleiner: wiederhole Suche in linker Hälfte größer: wiederhole Suche in rechter Hälfte –wenn Hälfte leer: nicht gefunden Bester Fall: O(1) Mittlerer Fall: O(n) Schlechtester Fall: O(n) Bester Fall: O(1) Mittlerer Fall: O(log 2 n) Schlechtester Fall: O(log 2 n)

26 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 326 Module

27 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 327 Getrennte Übersetzung a.h #include "a.h" a.cpp/cc Compile a.h *.h *.cpp/cc Link a.obj *.obj Compile ausführbares Programm

28 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 328 Module Datenabstraktion –abstrahiert von Realisierung der Datenstruktur Funktionale Abstraktion –abstrahiert vom Algorithmus Rumpf Schnittstelle Zugriff Modul Ziele: Änderungen im Rumpf ohne Auswirkungen auf Verwender, Wartbarkeit Zergliederung in Teile Arbeitsteilung Modul-Test Entwurf vor Realisierung, Softwarearchitektur

29 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 329 Modularten ADO : Abstraktes Daten-Objekt –Datenabstraktion –Exakt ein Objekt zur Laufzeit –Alle Operationen auf diesem Objekt –Allokation/Erzeugung und De-Allokation/Zerstörung durch Laufzeitsystem ADT : Abstrakter Daten-Typ –Datenabstraktion –Schablone, beliebig viele Instanzen zur Laufzeit erzeugbar –Instanz bei jeder Operation angeben –Allokation/Erzeugung und Deallokation/Zerstörung in Verantwortung des Programmierers FM :Funktionales Modul –Funktionale Abstraktion –Transformierendes Modul  Funktionsbibliothek –Kein "Gedächtnis"  Keine Seiteneffekte DA FA

30 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 330 Realisierung der Modularten (ADO, FM) Rumpf Schnittstelle ADO Header- Datei (.h) Implemen- tierungs- Datei (.cc/.cpp) bool ElementEinfuegen(int Element); bool ElementLoeschen(int Element);... static BinBaum baum; //Datenspeicher bool ElementEinfuegen(int wert) {... }... FM: ohne Datenspeicher, sonst gleiche Realisierung

31 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 331 Realisierung der Modularten (ADT) Rumpf Schnittstelle ADT class BinBaum { public: RefKnoten ErzeugeNeuenKnoten(int wert)... private: IntKnoten* wurzel;... }; struct BinBaum::IntKnoten {... } BinBaum::RefKnoten BinBaum::ErzeugeNeuenKnoten(int wert) {... } Header-Datei (.h) ImplementierungsDatei (.cc/.cpp)

32 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 332 Funktionales Modul (FM) - Umsetzung //trig.h double sinus(double x); double tan(double x); double cos(double x);... #include "trig.h" double sinus(double x) {... } double tan(double x) {... double cos(double x) {... } Header-Datei=Schnittstelle.cpp/.cc-Datei=Rumpf

33 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 333 Beispiel: ADT-BinBaum ADT-BinBaum: –Realisierung eines ADT BinBaum –Jeder Knoten hat Zeiger auf Vater –Beispiel für Entwicklung einer Datenstruktur Beispiel für Verwendung des ADT –main ADO Menge erstellen: –Realisierung mit Hilfe des ADT BinBaum –Menge nutzt BinBaum zur Speicherung ADO-BinBaum: –selber BinBaum, jetzt als ADO Beispiel für Verwendung des ADO –main

34 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 334 Definieren von Datenstrukturen Ziel: Binärer Baum mit Zeiger auf Vater Idee: 3 33 33

35 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 335 Definieren von Datenstrukturen Konkreteres Modell: 3 33 3 3

36 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 336 Definieren von Datenstrukturen Umsetzung in Programmiersprache C++: struct BinBaum::IntKnoten { IntKnoten* vater; int inhalt; IntKnoten* linkesKind; IntKnoten* rechtesKind; }; 3 IntKnoten* wurzel;

37 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 337 ADT-Umsetzung: Header-Datei // BinBaum.h: Schnittstelle für den ADT BinBaum. class BinBaum { // Der außen verwendete opake Datentyp für Bäume private: struct IntKnoten { int inhalt; IntKnoten* vater; IntKnoten* linkesKind; IntKnoten* rechtesKind; }; IntKnoten* m_Wurzel; public: typedef IntKnoten* RefKnoten; BinBaum(); // Konstruktor RefKnoten GibWurzel(); RefKnoten GibLinkesKind(RefKnoten vater); RefKnoten GibRechtesKind(RefKnoten vater); RefKnoten GibVater(RefKnoten aktuellerKnoten); RefKnoten ErzeugeNeuenKnoten(int wert); void SetzeWurzel( RefKnoten neueWurzel ); void EinhaengenKnotenLinks( RefKnoten vater, RefKnoten neuesKind ); void EinhaengenKnotenRechts( RefKnoten vater, RefKnoten neuesKind ); void SetzeWert( RefKnoten zuAendernderKnoten, int wert ); int GibWert( RefKnoten zuLesenderKnoten );... }; zusätzlicher "opaker" Datentyp zur gezielten Identifikation einzelner Knoten Navigation Manipulation Zugriff auf Inhalt "Geheime" Definition von IntKnoten

38 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 338 ADT-Umsetzung:.cpp/.cc-Datei #include "BinBaum.h" BinBaum::RefKnoten BinBaum::ErzeugeNeuenKnoten(int wert) { IntKnoten *knoten = new IntKnoten; knoten->inhalt = wert; knoten->vater = NULL; knoten->linkesKind = NULL; knoten->rechtesKind = NULL; return knoten; } Methode gehört zur Klasse BinBaum Initialisieren, vgl. Definition der Struktur Knoten erzeugen BinBaum::RefKnoten BinBaum::GibLinkesKind(RefKnoten vater) { return vater->linkesKind; } intern darf die Struktur zugegriffen werden aussen ist Struktur von vater nicht zugreifbar

39 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 339 Beispiel: ADT-BinBaum ADT-BinBaum: –Realisierung eines ADT BinBaum –Jeder Knoten hat Zeiger auf Vater –Beispiel für Entwicklung einer Datenstruktur Beispiel für Verwendung des ADT –main ADO Menge erstellen: –Realisierung mit Hilfe des ADT BinBaum –Menge nutzt BinBaum zur Speicherung ADO-BinBaum: –selber BinBaum, jetzt als ADO Beispiel für Verwendung des ADO –main

40 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 340 ADT-Umsetzung: Verwendung #include "BinBaum.h" BinBaum baum; void main() { BinBaum::RefKnoten kn=baum.ErzeugeNeuenKnoten(42); baum.SetzeWurzel(kn);... kn=baum.GibLinkesKind(baum.GibWurzel()); cout << baum.GibWert(kn); } Instanz des ADTs (der Klasse) Aufruf von Methoden der Instanz Anmerkung: ADT in der Klausur immer als Klasse in der Praxis (und auch in Vorlesung und Übung) auch anders

41 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 341 Beispiel: ADT-BinBaum ADT-BinBaum: –Realisierung eines ADT BinBaum –Jeder Knoten hat Zeiger auf Vater –Beispiel für Entwicklung einer Datenstruktur Beispiel für Verwendung des ADT –main ADO Menge erstellen: –Realisierung mit Hilfe des ADT BinBaum –Menge nutzt BinBaum zur Speicherung –Nur Schnittstelle verwenden! ADO-BinBaum: –selber BinBaum, jetzt als ADO Beispiel für Verwendung des ADO –main

42 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 342 ADO-Umsetzung: Header Datei //Menge.h //Realisierung einer Menge basierend auf einem Binärbaum //Fuegt das Element item in die Menge ein //Rueckgabewert: true, wenn erfolgreich // false, wenn item schon Element der Menge bool ElementEinfuegen(int Element); //Entfernt das Element item aus der Menge //Rueckgabewert: true, wenn erfolgreich // false, wenn item nicht Element der Menge bool ElementLoeschen(int Element); //Testet, ob item in der Menge enthalten ist //Rueckgabewert: true, wenn ja // false, sonst bool istElement(int Element); //Testet, ob die Menge leer ist //Rueckgabewert: true, wenn ja false, sonst bool istLeer(); Bei ADO: nur öffentliche Schnittstelle = Header-Datei MengeBinBaum ADO ADT

43 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 343 ADO-Umsetzung:.cpp/.cc-Datei #include "Menge.h" #include "BinBaum.h" BinBaum baum; bool ElementEinfuegen(int wert) { BinBaum::RefKnoten knoten; BinBaum::RefKnoten neuerKnoten; if (baum.GibWurzel()==NULL) { //ist der Baum leer? neuerKnoten=baum.ErzeugeNeuenKnoten(wert); baum.SetzeWurzel(neuerKnoten); return true; } else {... } return false; }... genau ein Datenobjekt vom Typ BinBaum Implementierung von Funktionen

44 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 344 Beispiel: ADT-BinBaum ADT-BinBaum: –Realisierung eines ADT BinBaum –Jeder Knoten hat Zeiger auf Vater –Beispiel für Entwicklung einer Datenstruktur Beispiel für Verwendung des ADT –main ADO Menge erstellen: –Realisierung mit Hilfe des ADT BinBaum –Menge nutzt BinBaum zur Speicherung ADO-BinBaum: –gleicher BinBaum wie oben, jetzt als ADO Beispiel für Verwendung des ADO –main

45 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 345 ADO-Umsetzung (mit Typ): Header-Datei // BinBaum.h: Schnittstelle für den ADO BinBaum. struct IntKnoten; typedef IntKnoten* RefKnoten; RefKnoten GibWurzel(); RefKnoten GibLinkesKind(RefKnoten vater); RefKnoten GibRechtesKind(RefKnoten vater); RefKnoten GibVater(RefKnoten aktuellerKnoten); RefKnoten ErzeugeNeuenKnoten(int wert); void SetzeWurzel( RefKnoten neueWurzel ); void EinhaengenKnotenLinks( RefKnoten vater, RefKnoten neuesKind ); void EinhaengenKnotenRechts( RefKnoten vater, RefKnoten neuesKind ); void SetzeWert( RefKnoten zuAendernderKnoten, int wert ); int GibWert( RefKnoten zuLesenderKnoten );... Vorabdeklaration des Privaten Typs, Definition folgt im Rumpf Verwender kann diesen Typ zum gezielten Zugriff auf einzelne Knoten nutzen Methoden-Deklarationen Auch ein ADO kann einen Typ exportieren: Die eigentliche Datenstruktur (der Baum) existiert nur ein mal => ADO. Zusätzlich gibt es einen weiteren Typ zur Identifikation von Knoten.

46 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 346 ADO-Umsetzung(mit Typ):.cpp/.cc-Datei #include "BinBaum.h" struct IntKnoten { int inhalt; IntKnoten *vater, *linkesKind, *rechtesKind; }; IntKnoten* m_Wurzel; RefKnoten ErzeugeNeuenKnoten(int wert){ IntKnoten *knoten = new IntKnoten; knoten->inhalt = wert; knoten->vater = NULL; knoten->linkesKind = NULL; knoten->rechtesKind = NULL; return knoten; }... Vollständige Definition des Typs Wurzel des Baumes, private Variable Methoden- Implementierungen

47 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 347 Beispiel: ADT-BinBaum ADT-BinBaum: –Realisierung eines ADT BinBaum –Jeder Knoten hat Zeiger auf Vater –Beispiel für Entwicklung einer Datenstruktur Beispiel für Verwendung des ADT –main ADO Menge erstellen: –Realisierung mit Hilfe des ADT BinBaum –Menge nutzt BinBaum zur Speicherung ADO-BinBaum: –selber BinBaum, jetzt als ADO Beispiel für Verwendung des ADO –main

48 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 348 Generizität

49 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 349 Generizität Allgemein Gewisse „Stellschrauben“ (generische Instanzparameter) in der Realisierung von einzelnen Funktionen oder auch ganzen ADTs offenlassen –Nützlich bei Kollektionen: Stellschrauben sind Eintragstyp und Größe template class Buffer { public: void enqueue(T x);... private: T internesFeld[size]... }; „Stellschrauben“ werden vom Verwender je nach Bedarf „festgezogen“ (Erzeugung spezieller Typ-Instanzen) typedef Buffer IntBuffer; typedef Buffer PersonBuffer;... IntBuffer myIntBuffer; myIntBuffer.enqueue(42); myIntBuffer.enqueue(„Ich will rein!“); //Fehler Compile-Zeit Nutzen: Vermeidung von Code-Redundanz (kein Extra-Buffer für jeden Eintragstyp und jede Größe zu implementieren)

50 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 350 ADT DLList: Schnittstelle (.h) class DLList { public: DLList(); void append(int item); void deleteCurrent(); void deleteIndex(int index); void toStart(); void toEnd(); void next(); void prev(); int read();... private: struct ListItem { int value; ListItem *next, *prev; }; ListItem *first; // Zeiger auf das erste Element der Liste ListItem *last; // Zeiger auf das letzte Element der Liste ListItem *current; // Zeiger auf das aktuelle Element };

51 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 351 ADT DLList: Rumpf (.cc)... void DLList::prev() { if (current == NULL) { cerr << "DLList::prev: current == NULL" << endl; return; } if (current == first) { cerr << "DLList::next: am Anfang der Liste" << endl; return; } current = current->prev; } int DLList::read() { if (current == NULL) return -1; return current->value; }...

52 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 352 ADT GenDLList: Schnittstelle (.h) template class GenDLList { public: GenDLList(); void append(Value_T item); void deleteCurrent(); void deleteIndex(int index); void toStart(); void toEnd(); void next(); void prev(); Value_T read(); Value_T readNext();... private: struct ListItem { Value_T value; ListItem *next, *prev; }; ListItem *first; // Zeiger auf das erste Element der Liste ListItem *last; // Zeiger auf das letzte Element der Liste ListItem *current; // Zeiger auf das aktuelle Element };

53 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 353 ADT GenDLList: Rumpf (.cc) #ifndef __INC_GenDLList_cc #define __INC_GenDLList_cc... template void GenDLList ::prev() { if (current == NULL) { cerr << "GenDLList::prev: current == NULL" << endl; return; } if (current == first) { cerr << "GenDLList::next: am Anfang der Liste" << endl; return; } current = current->prev; } template Value_T GenDLList ::read() { if (current == NULL) return NULL; return current->value; }... #endif

54 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 354 ADT LecAdm: Schnittstelle (.h) #include „GenDLList.cc“ class LecAdm { public: void AddLecture(std::string lecName); void RemoveLecture(std::string lecName);... private: // 1. Deklaration der Typ-Instanz 'IntList' typedef GenDLList IntList; // 2. Deklaration der Verbundtypen // 'Student' und 'Lecture' struct Student { int matNr; std::string name; }; struct Lecture { std::string name; IntList listeners; }; // 3. Deklaration der Typ-Instanzen 'StudentList' und 'LectureList' typedef GenDLList StudentList; typedef GenDLList LectureList; // 4. Deklaration der Listen (Datenobjekte) 'students' und 'lectures' StudentList students; LectureList lectures; };

55 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 355 ADT LecAdm: Rumpf (.cc) #include „LecAdm.h“ void LecAdm::AddLecture(string lecName) { Lecture* newLec = new Lecture; newLec->name = lecName; lectures.append(newLec); } bool LecAdm::AddStudentToLecture(int matNr, string lecName) { lectures.toStart(); while (!lectures.isAtEnd() && lectures.read()->name != lecName) { lectures.next(); } if (lectures.read()->name == lecName) { lectures.read()->listeners.append(matNr); return true; } else { return false; }...

56 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 356 Objektorientierung

57 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 357 Objektorientierung: Klassen und Vererbung Circle void draw() void setMid() void setRad()... GraphicObject void draw()... Rectangle void draw() void setUL() void setLR()... class GraphicObject { private:... public: virtual void draw(...); } class Rectangle: public GraphicObject { private:... public: void draw(...); void setUL(int x, int y); void setLR (int x, int y); } class Circle: public GraphicObject { private:... public: void draw(...); void setMid(int x, int y); void setRad(int x, int y); }

58 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 358 Objektorientierung: Dynamische Bindung GraphicObject *go; Circle *c; Rectangle *r; GraphicObjectList gl; r=new Rectangle(); r->setUL(10,10); r->setLR(15,25); gl.add(r); c=new Circle(); c->setMid(25,30); c->setRad(10); gl.add(c); gl.gotoFirst(); while (gl.hasCurrent()) { go=gl.getCurrent(); go->draw(); gl.gotoNext(); } class GraphicObject { private:... public: virtual void draw(...); } speziellste Methode ausführen GraphicObjectList... GraphicObject* Circle Rectangle

59 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 359 Objektorientierung: Vorsicht mit virtual ! class A { public: void f(); virtual void g(); }; class B : public A { public void f(); void g(); }; void A::f() { cout << "f von A"; } void A::g() { cout << "g von A"; } void B::f() { cout << "f von B"; } void B::g() { cout << "g von B"; } void main() { A *a; B *b; b=new B(); b->f(); b->g(); a=b; a->f(); a->g(); } kein virtual  f von A virtual  g von B f und g von B Ausgabe: f von B g von B f von A g von B

60 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 360 ADO-Umsetzung: Verwendung #include "BinBaum.h" void main() { RefKnoten kn=ErzeugeNeuenKnoten(42); SetzeWurzel(kn);... kn=GibLinkesKind(GibWurzel()); cout << GibWert(kn); } Es muss keine Instanz angelegt werden, da genau eine Instanz existiert Daher muss auch keine Instanz beim Zugriff angegeben werden Der Typ RefKnoten wird zum Zugriff auf einzelne Knoten genutzt

61 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 361

62 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 362

63 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 363

64 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 364

65 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 365

66 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 366

67 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 367

68 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 368

69 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 369

70 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 370

71 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 371

72 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 372

73 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 373

74 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 374

75 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 375

76 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 376

77 Grundlagen der Informatik: Algorithmen und ProgrammiertechnikenRWTH Aachen – Lehrstuhl für Informatik 377