Objektorientierte Programmierung – die Programmiersprache C++ –

Einführung in die objektorientierte Programmierung - die Programmiersprache C++Semester: 4HTWM(Hochschule für Technik undWirtschaft Mittweida –University Of Applied Sciences)Semester: IVFach: ObjektorientierteProgrammierung – dieProgrammiersprache C++Vorlesende: Prof. IngeborgJacobiObjektorientierteProgrammierung– die Programmiersprache C++ –Mitschrift von: Drost IsabelMassaneier Str. 5504736 WaldheimsendMail@isabel-drost.dehttp://www.isabel-drost.deMitschrift von: Drost, Isabel – if99wp1 Seite 1 von 12

Einführung in die objektorientierte Programmierung - die Programmiersprache C++Semester: 4Fehler! Es konnten keine Einträge für ein Abbildungsverzeichnis gefunden werden................37. friend-Funktionen und friend-Klassen.................................................................................47.1. Idee der friends............................................................................................................................47.1.1. friend-Funktionen .................................................................................................................................. 47.1.2. friend-Klassen........................................................................................................................................ 47. 2. Überschreiben von Operatoren mit friend - functions ...........................................................47.2.1. Voraussetzung ....................................................................................................................................... 47.3. friend-funktionen und die stream Ein-/ Ausgabe.....................................................................58. Mehrfachvererbung...............................................................................................................58.1 Struktur bei der Mehrfachvererbung:.......................................................................................59. Klassenschablonen ................................................................................................................69.1. Funktionstemplates.....................................................................................................................69.2. Klassentemplates.........................................................................................................................610. Standard-Template Library (STL) ......................................................................................710.1. Eigenschaften eines Containers: .............................................................................................710.2. Konzepte der STL .....................................................................................................................7(1) Feldklasse................................................................................................................................................... 7(2) Listenklasse................................................................................................................................................ 8(3) Schlussfolgerungen.................................................................................................................................... 9(4) Iterator für Feldklasse ................................................................................................................................ 9(5) Iterator für Listenklasse ............................................................................................................................. 9(6) Zusammenfassung: .................................................................................................................................... 9(7) Ist die STL objektorientiert? .................................................................................................................... 1010. 2 Container .................................................................................................................................10Zu den festen Typnamen: .............................................................................................................................. 1010.3 Der Container Vector ..............................................................................................................1011. Die ereignisorientierte Programmierung in C++.............................................................1111.1. Programmieren von Oberflächen..........................................................................................11Ereignisse in C++ .......................................................................................................................................... 11Prinzipielle Vorgehensweise ......................................................................................................................... 12Mitschrift von: Drost, Isabel – if99wp1 Seite 2 von 12

Einführung in die objektorientierte Programmierung - die Programmiersprache C++Semester: 4Fehler! Es konnten keine Einträge für einAbbildungsverzeichnis gefunden werden.Mitschrift von: Drost, Isabel – if99wp1 Seite 3 von 12

Einführung in die objektorientierte Programmierung - die Programmiersprache C++Semester: 47. friend-Funktionen und friend-Klassen7.1. Idee der friends• in einer Klasse können andere Klassen oder Funktionen (keine Methoden!) zu „Freunden“ erklärt werden• die so gewonnen Freunde können in das Innere der Klasse hineinsehen und auf die Funktionen darinzugreifen (über die eigentliche Schnittstelle hinaus)• eigentlich ein Verstoß gegen die Ideen der OOP7.1.1. friend-Funktionen• ist C-Funktion• Erklärung zum Freund erfolgt über friend[Prototyp]• Definition der Funktion in passendemGültigkeitsbereich (z.B. global oderbenannt) ohne nochmals das Schlüsselwort„friend“ bei der Definition zu verwenden(nur bei der Deklaration!)• in der Parameterliste ist die Freundklasse(die, die mich zum Freund nimmt) überein Objekt anzugeben• wo ich die friend Funktion ist egal (obprivate oder public)• Zugriff erfolgt über [Objektnamen].[Datum]oder [Objektnamen].[Methode]alphaprivate datafriendfunctionsfriend [returnTyp] [funktionname](obj myFriendClass)friend betaaccessbetaprivate datafunctions7.1.2. friend-KlassenAbbildung 2• alle Methoden einer Klasse werden zuFreunden der zweiten Klasse erklärt• über Klassennamen• Form: friend [Klassenname] in Funktionen zu befreundeten Klassen (beta z.B.)• zur Arbeit mit solchen Klassen brauche ich Objekte (z.B. alpha a; beta b; b.aendere() //wobei die Funktionaendere die Daten aus alpha ändern/ nutzen soll)7. 2. Überschreiben von Operatoren mit friend - functions7.2.1. VoraussetzungClass Komplex{Komplex operator+(float,komplex)}Aufruf: k.operator+(7);k+7;normal nicht möglich: 7+k;• Klasse, in der Operatoren überschrieben werden sollen• Funktionsname: operator[Zeichen] ([Parameter]) (diese Funktionbefindet sich in einer aktuellen Klasse)• Aufruf der Funktion: [Objektname].operator[Zeichen] ([Paramter])bisher: Objektname stammt von aktuellen Objekt, Typ der Parameterkann von unterschiedlichen Typen sein (auch gleich dem aktuellenObjekt)• bei einargumentigen Funktionen muß der returnTyp gleich demParametertyp sein• bei mehrstelligen Operationen, die mit friend-Funktionen überschriebenwerden, muß der erste Operant nicht vom Klassentyp seinMitschrift von: Drost, Isabel – if99wp1 Seite 4 von 12

Einführung in die objektorientierte Programmierung - die Programmiersprache C++Semester: 47.3. friend-funktionen und die stream Ein-/ Ausgabe• in i-/ ostream sind die Operatoren „“ überschrieben worden• einfache Ein-/ Ausgabe mit cin>>Objekt und cout/

Einführung in die objektorientierte Programmierung - die Programmiersprache C++Semester: 4Beim Mehrfachvererben gilt im Allg., dass ich Methoden gezielt mittels Klassennamen ansprechen muß. Dies istein Nachteil gegenüber der Arbeit mit der einfachen Vererben.Die Mehrfachvererbung könnte ich eigentlich auch durch Objekte mit Objekten als Komponenten auch erreichen.9. Klassenschablonen9.1. FunktionstemplatesKlassenschablonen oder parametriesierte Klassen oderKlassentemplates und generische Klassen sind Begriffe,die prinzipiell das gleiche bedeuten.Wenn eine Klasse unter Verwendung formaler Datentypen/Klassen definiert wird, nennt man dieses KonstruktKlassenschablone.Aus der Klassenschablone können durch Angabekonkreter Typen für die formalen Typen mehrere konkreteKlassendef. generiert werden.Vorgehensweise:TemplateErg.Typ Funtkionsname(Typ_1 Par_1, Typ_2 Par_2 ...){Funktionskörper}Die Bezeichnungen für die Ti sind frei wählbar. Jederder FormalenTypname Ti muss mindestens einmalanstelle eines Typ_ in der Parameterliste vorkommen.Prinzipbeispiel: template void f( T t) {...}Die formalen Typen stellen also Parameter für die Klasse dar. Dabei ist die Bezeichnung für den formalen Typfrei wählbar.Zur Compilezeit werden durch Textersetzung aus formalen Typen und Templates konkrete Klassen.Voraussetzung für den Einsatz von Klassenschablonen ist aber, dass die Anweisungen in der Klasse so sind,dassdie Ersetzung sinnvoll ist und auch synaktisch korrekt wird.Die Idee ist, aus einem Template werden viele Klassen generiert.Implizite Erzeugung von Templates: f(12) f(12);Vorteil: Möglichkeit, normale Funktion hat Vorrang, wenn es also eine normale Methode gibt, wird dasTemplate nicht aufgelöstEinfache NutzungExplizite Erzeugung von Templates: template void f(double);9.2. KlassentemplatesGrundidee:Ableitung vieler Klassen, die sich nur in wenigen Punkten unterscheiden.Vorraussetzung:Methoden in der Klasse lassen eine sinnvolle Generalisierung zu, die eine sematisch undsyntaktisch korrekte Ersetzung ermöglicht.Form:template class K1Name{Attribute und Methoden ...};Wo finden sich die formalen Typen im Klassentemplate wieder?- als Attribute oder innerhalb von AttributenMitschrift von: Drost, Isabel – if99wp1 Seite 6 von 12

Einführung in die objektorientierte Programmierung - die Programmiersprache C++Semester: 4- als Parameter zu MethodenDer Name der Klassenschablone ist: K1name.Bei der Methodendefinition anzugeben ist:template Erg.Typ K1Name::Methodenname( ... ){ ... }Klasse wird im allgemeinen durch die Nutzung erzeugt. Nutzung heißt hier Objekterzeugung => impliziteErzeugung von Klassen:K1Namedabei sind die Typen jetzt konkrete Standardtypen oder Klassen.Explizite Erzeugung einer Klasse:Implizites Erzeugen ist dabei jedoch günstiger, da ichTemplate class K1Namemich dann beim Compilieren nicht darum kümmernmuß, in welcher Reihenfolge compiliert wird. Macheich es explizit, muß ich selber aufpassen, dass ich nicht ausversehen was zweimal definier. Im Impliziten wirddie entsprechende Klasse nur beim ersten Nutzen erzeugt.• Verwendung von Templates für bestimmte Algorithmen, z.B. Sortieralgorithmen.• Zu den aus den Klassentemplates erzeugten Klassen können friends (Funktionen oder Klassn) existierten.• Vererbung von Templates ebenfalls möglich.• Neu ist, das der formale Parameter entweder ein Parameter mit Parameternamen oder ein zur Compilezeitberechenbarer Ausdruck sein kann – gewisse Werte können so als Konstanten in die Klassen bringen10. Standard-Template Library (STL) ein Teil der Standardbibliothek, im Namensbereich std definiert Zweck: stellt mittels Templates Container zur Verfügung Begriff: Container(klassen) oder Behälterklasse ist eine Klasse zum Verwalten von Objekten gleichen Typs/gleicher Klasse10.1. Eigenschaften eines Containers:• Datenstruktur zum Aufbewahren der Objekte• Grundoperationen (Einfügen eines Elements, Löschen eines Elements, Information über die Anzahl derObjekte, Information über Existenz von Objekten, Sichern und Wiederherstellen von Containern)• dies ist aus der Programmierung schon bekannt in Form von Feldern, Listen ...10.2. Konzepte der STL• anhand von Prinzipbeispielen(1) FeldklasseVorteil: Zugriff über den Index einfachNachteil: feste maximale Anzahl (konstant)man könnte das "Feld" auf dem Heap anlegen undsomit zur Laufzeit organisieren: stelle währendder Laufzeit Platz für das Feld auf dem Heapbereit und greife auf die Elemente einfach viacin>> int anzahl;int *pfeld=new int[anzahl];// lege nur Platz auf dem Heap für eine bestimmte// Anzahl Elemente an und zeige auf die Einheiten// So sind nie Objekte selbst erzeugbar!Index zu (letzteres ermöglicht die C-eigene Adressrechnung. Dies macht aber auch SegmentationFaultseinfach möglich)Mitschrift von: Drost, Isabel – if99wp1 Seite 7 von 12

Einführung in die objektorientierte Programmierung - die Programmiersprache C++Semester: 4Auf dieser Basis soll eine Klasse erstellt werdenpfeldtemplate class Feld{public:Feld (int anzahl=0):n(anzahl, t(new T([anzahl]){} //Konstruktor mit Initlistint suchen (const T& x) const;private:int n; //ElementeanzahlT* t; //Zeiger auf Heap};templateint Feld::suchen (const T& x const{for(int i=0;it;return 0;}Liste li;...int* zeiger=li.suchen(17);if(z!=0) cout

Einführung in die objektorientierte Programmierung - die Programmiersprache C++Semester: 4(3) Schlussfolgerungen• hier wurden zwei von vielen möglichen Container (Baum, Heap, Stack ... ) betrachtet• um n Container zu erreichen, braucht man n Klassen mit je m Manipulierungsfuntkionen, führt zu n*mFunktionen• Idee in der STL: Realisierung einer kleinen Bilbliothek, dabei wurde die Anzahl der Funktionen in den Containerngespart• Konsequenz: Aufbau der Klassen derart, dass vereinheitlichte Funktionen nutzbar sind. Zum Beispiel eineFunktion für viele Container.• Dies könnte man so realiesieren, dass die Funktionen sich außerhalb der Klassen selbst befinden und derKlassenaufbau einheitlich organisiert ist.• zum Beispiel folgt daraus aber auch, dass ich ein Feld neu betrachten mußint* z=f;while((z!=f+n)&&(*z!=x))z++; //führt dazu, dass ich soweit weiter gehe, wie ein Element//breit ist – angeblichif(z!=f+n) //gefundenFELD Fhtemplate T* suchen(T*start, T* ende, T x){T* z=start;while(z!=ende && *z!=x)z++return z;}int* z=suchen(f, f+n, 25);if(z!=f+n) //gefundenBei der neuen Suchfkt. werden 1 Parametertypen genutzt: T für das zu vergleichende Element und TÜfür Zeiger.Wenn man für dieses TÜ einen neuen Template-Parameter einführt, T*->iter -> durch formaleErsetzung:template Iter suchen (Iter start, Iter ende, Tx){while ... start++;return start;}In der Stdlib gibt es Iteratoren für Feldklassen, Listenklasse ...(4) Iterator für Feldklasse• Iteratoren, um sich Elementweise durch den Container zu hangeln(5) Iterator für Listenklasse(6) Zusammenfassung:• Jede Containerklasse hat eigenen Iteratortyp, der public ist• Iterator – zum Durchlaufen des Containers• Fester Name iterator wird genutzt• gemeinsame Suchfunktion für 2 Klassen – Verallgemeierung• Suchen mit Iteratoren ist unabhängig vom InhaltMitschrift von: Drost, Isabel – if99wp1 Seite 9 von 12

Einführung in die objektorientierte Programmierung - die Programmiersprache C++Semester: 4• STL hat Container, Iteratoren, Algorithmen• Kopplung zwischen Containern und Algorithmenerfolgt über IteratorenAlgorithmenIteratorenContainer(7) Ist die STL objektorientiert?• Kapslung von Daten und Funktionen (ADT) nicht völlig• Polymorphismus gibt es nicht (keine virtuellen Fkt.)10. 2 Container• verwalten Objekte gleichen Typs• Das Aufnehmen der Objekte erfolgt durch Kopieren. Objekte im Container leben nicht länger als der Container selbst Speicherverwaltung erfolgt automatisch Aufnehmen setzt CopyKonstruktor und die Operator Anweisung "=" voraus im allgemeinen sagt man, das kanonische Klassen geeignet sind für die STL- CopyConstructor- Standardkonstruktor- Destruktor passend für die Klasse- Zuweisungsoperator- operator==- will ich Containern ordnen: operator< oder operator>• gewisse Typsicherheit, da die Objekte alle gleichen Typs sind• jeder Container hat eine eigene Schnittstelle Methoden zu seiner Verwaltung, in denen z.T. auch die Iteratoren genutzt werden fest vorgegebene Typnamen• es existieren weitere Funktionen für Container in Algorithm (in )• zusätzlich verschiedene Bibliotheken wie , Zu den festen Typnamen:• haben feste Namen size_type ... unsigned zum Zählen value_type ... Typ des Containers pointer ... Templatepointer (T*) reference ... T& iterator ... veweist auf ein Objekt im Container10.3 Der Container Vector• entspricht dynamischen Feld mit anpaßbarenGrenzen• Grenzen werden automatisch bei der Aufnahmevon Elementen angepasst• Hinweise auf gewünschte Größe sind möglichaber nicht bindendfrontMethoden von Vector:• Definition über:vector(size_type n)vector v(10)• Füllen des Vectors über "void push_back(T& x)"• Leeren des Vectors über "T pop_back()"at(4)operator[z]backpop_backpush_backMitschrift von: Drost, Isabel – if99wp1 Seite 10 von 12

Einführung in die objektorientierte Programmierung - die Programmiersprache C++Semester: 4• Umfang erfragen über "size_type v.size()"• Zugriff auf Elemente erfolgt über reference front() reference back() reference v[i] reference at[i] nur at prüft den Index auf Vorhandensein: v[2]=13 gibt vielleicht Fehler; v.at[2]=13 gibt garantiertkeinen Fehler, liegt der Index außerhalb, tritt eine out_of_range-Exception auf, die ich via try...catchabfangen kann• andere Funktionen sind meist mit Iteratornutzung implementiert: iterator.insert (iterator p, const T&t); (vor p t einfügen) Definieren von Iteratoren:- vector :: iterator it;- Durchsuchen: iterator begin();iterator encr(); (iterator++ hüpft nicht eine Adresslänge sondern genau eineEinheit, ein Element weiter)11. Die ereignisorientierte Programmierung in C++11.1. Programmieren von OberflächenAnfang: in Smalltalk mit Einbeziehen der OberflächenIdee: Prinzip der Trennung zwischen den Objekten mit den eigentlichen Inhalten und Methoden und denObjekten für die Darstellung/ OberflächeEreignisse in C++• zu Oberflächen wird eine Schnittstelle gebraucht stromorientierte Ein-/ Ausgabe im allgemeinen in bestimmten Bibliotheken vorhanden in C++: Streamobjekte für die Arbeitsweise von Programmen nach dem sog. Batch-/StapelprinzipEreignisliste nur nach Aufforderung sind Daten zu erfassen ereignisorientierte Arbeitsweise Programm arbeitet nach dem PrinzipErfasse Ereignis ...while (Ereignis != Endeereignis)do {Ereignis bearbeiten;Ereignis einlesen;}Anwendungsprogramm Voraussetzung: Betriebssystem leitet Ereignisse an dasAnwendungsprogramm weiter, das diese verarbeiten können muß Arbeit im Hintergrund: Auffangen und weiterleiten vonunbehandelte Ereignisseauftretenden Ereignissen Menge der Ereignisse hängt vom BS ab• Die Weiterleitung von Ereignissen erfolgt bei Windows über eine Ereignisliste, die vom BS gesetzt wird• Ereigniss in C++ werden in den MFC verpackt und können von da aus leichter behandelt werden.Behandlungsfkt. für EreignisseMitschrift von: Drost, Isabel – if99wp1 Seite 11 von 12

Einführung in die objektorientierte Programmierung - die Programmiersprache C++Semester: 4Prinzipielle Vorgehensweise• Zusammenklicken der Anwendung via VS, Nutzung der MFC• Einlesen des BSchirmInhaltes: UpdateData(TRUE);• Anzeigen des BSchirmInhaltes: UpdateData(FALSE); (alle Felder im Fenster füllen, davor m-Variablerichtig stellen(?) )Mitschrift von: Drost, Isabel – if99wp1 Seite 12 von 12