Post on 28-Mar-2019
Die Programmiersprache
C++
Objektorientierter Ansatz
Dr.-Ing. E. Thiem Datum: 25.2.2018
class adressen
{ private: string name[30];
string vorname[30];
string strasse[40];
string ort[40];
string telefon[20];
string eMail[20];
public: int adr_eingeben();
int adr_schreiben();
int adr_listen();
};
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 103 Objektorientierter Ansatz
Gliederung
5 Objektorientierte Programmierung mit C++ ................................................................. 104
5.1 Idee ........................................................................................................................ 104
5.2 Objekte und Methoden ........................................................................................... 104
5.3 Klassen und die OOP ............................................................................................ 105
5.4 Konstruktoren und Destruktoren ............................................................................ 110
5.5 Vererbung .............................................................................................................. 113
5.6 Polymorphie ........................................................................................................... 117
5.7 Aufgaben zum Kapitel 5 ......................................................................................... 119
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 104 Objektorientierter Ansatz
5 Objektorientierte Programmierung mit C++
5.1 Idee
Die heute schon als klassisch bezeichnete Methodik der Softwareentwicklung, die wir als
„strukturiert“ bezeichnet haben, enthält grundlegende Ideen und Bestandteile zur Bewälti-
gung großer, komplexer Probleme.
Die rasche Entwicklung der Hardware in den zurückliegenden Jahren hat der sich kaum
weiter entwickelten Methodik der Softwareentwicklung den Ruf beschert „hinterher zu hin-
ken“.
Die OOP (kurz für Objektorientierte Programmierung), anfangs auch hochwissenschaftlich
als objektorientiertes Paradigma bezeichnet, ist eine der wichtigsten Antworten der In-
formatik als Wissenschaft auf diesen Vorwurf.
In den bisherigen Kapiteln wurden für die Beschreibung der Daten-Basis Strukturen wie
array, struct und für die Beschreibung der Programm-Basis wurden Funktionen ver-
wendet.
Die Grundidee der OOP besteht darin, daß zusammengehörige Strukturen aus Pro-
gramm- und Daten-Basis zu einer eigenen, neuartigen Struktureinheit – Klasse - zu-
sammengefaßt werden.
5.2 Objekte und Methoden
Das objektorientierte Paradigma geht davon aus, dass ein Softwaresystem aus Objekten
besteht, an denen Methoden (Verrichtungen) ausgeführt werden.
Die Objekte mit seinen Eigenschaften (auch Attribute genannt) werden durch Daten, die
Methoden durch Funktionen beschrieben.
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 105 Objektorientierter Ansatz
5.3 Klassen und die OOP
In der OOP werden die Objekte mit gleichen Eigenschaften und Methoden zu einer
Klasse zusammengefasst.
Im Sinne der OOP wird also eine Klasse durch die Beschreibung der Datenstrukturen
und der anwendbaren Funktionen definiert.
Beispiel:
Name
Strasse
Ort
Telefon
Die Klasse Adressen mit den Eigenschaften und den Methoden
Beispiel:
Name: Jana Müller
Strasse: Kleiner Weg 25
Ort: 34000 Seefeld
Telefon: 0734/9435
Dieses Objekt hat bestimmte Eigenschaften, auf die mit Methoden zugegriffen werden kann.
Attribut: Attributwert
Adresse eingeben
Adresse anzeigen
.......
Adresse eingeben
Adresse anzeigen
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 106 Objektorientierter Ansatz
In C++ steht zur Klassendefinition die class-Anweisung zur Verfügung:
Programmausschnitt:
class adressen { private: string name; string vorname; string strasse; string ort; string telefon; string eMail; public: int x; int adr_eingeben(void); int adr_schreiben(void); int adr_listen(void); };
//Datendefinition mit Hilfe von
//Datentypen
//öffentliche Ganzzahl-Variable x,
//Methodendefinitionen mit Hilfe
//von Funktionen
Die Schlüsselworte private, public und protected haben ihren Sinn im Zusammenhang
mit der Datenkapselung innerhalb der Objekte der Klasse hinsichtlich des äußeren Zu-
griffs.
Zugriffsbeschränkungen zu den Elementen (Daten und Funktionen):
private: es darf nur innerhalb der Klasse zugegriffen werden (privat)
public: es liegen keine Zugriffsbeschränkungen vor (öffentlich)
protected: der Zugriff ist nur innerhalb der Klasse und den abgeleiteten Klassen
möglich
UML-Darstellung
adr_eingeben()
adr_schreiben()
adr_listen()
name
strasse
ort
telefon
(adressen)
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 107 Objektorientierter Ansatz
Bezugnahme Klasse-Methode herstellen:
Die Funktion wird innerhalb der Klasse deklariert und außerhalb der Klasse definiert. Der
Scope-Operator "<Klassenname> :: <Methodenname>“ sichert dabei die Zuordnung
einer benutzten Methode zur Klasse.
Programmausschnitt:
int adressen :: adr_eingeben(void) { cout<<"Name: " ; cin >>name; cout<<"Vorname: " ; cin >>vorname; //usw. return 1; }
// Zuordnung Methode zur Klasse adressen
Verwendung der Klasse:
Ein Objekt ist eine Variable vom Typ einer vorgegebenen Klasse. Das Anlegen eines Ob-
jektes erfolgt nach folgender Vorschrift:
Beispiele: class neu adressdaten;
class adressen adressdaten[10];
Für den Zugriff auf Elementfunktionen einer Klasse gilt allgemein:
Beispiele: adressdaten.adr_eingeben();
adressdaten[0]. adr_eingeben();
Objektname . Elementfunktion ( )
Klassenname Objektname (Wertübergabe)
DatenTyp Klassenname :: Funktionsname( )
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 108 Objektorientierter Ansatz
Programmausschnitt:
Beispiel in C++: Projekt öffnen
void main(void)
{
class adressen adressdaten[10];
adressdaten[0].adr_eingeben();
adressdaten[0].adr_schreiben();
}
// Anlegen eines Objektes adressdaten
// mit insgesamt 10 Elementen
// Zugriff auf Methoden der Klasse adressen
//auf 1. Element des Objektes
weitere Beispiele:
adressen ad1; Objektdefinition (Instanz) von „ad1“ zur Klasse „adressen“
ad1.adr_eingeben(); Methodenaufruf klappt als „äußerer“ Zugriff, weil adr_eingeben
public vereinbart ist.
ad1.name="Tim"; Compilerfehler, weil name private vereinbart ist.
ad1.x=7; kein Fehler, weil x eine public-Variable ist
Innerhalb der Klassendefinition (vor allem bei der Definition der Funktionen) kann auf jede
vereinbarte Variable (auch private und protected) zugegriffen werden. z.B. name = "Tim".
Die Namenstypen protected und private unterscheiden sich bezüglich einer Basisklasse
nicht.
In abgeleiteten Klassen kommt es zu Unterschieden beim inneren Zugriff.
Ein äußerer Zugriff ist nur für „public“-Größen möglich.
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 109 Objektorientierter Ansatz
Zusammenfassung des bisherigen Beispiels:
Beispiel in C++: Projekt öffnen
#include <iostream> #include <string> using namespace std;
class adressen {
private: string name; string vorname; string strasse; string ort; string telefon; string eMail;
//int x; public:
int x; int adr_eingeben(void); int adr_schreiben(void); int adr_listen(void);
}; int adressen::adr_eingeben(void) { cout<<"Name: "; cin >>name; cout<<"Vorname: "; cin >>vorname; return 1; } int adressen::adr_schreiben(void) { cout<<"Name: "; cout <<name<<endl; cout<<"Vorname: "; cout <<vorname<<endl; return 1; } int adressen::adr_listen(void) { return 1; } void main(void) {
class adressen adressdaten[10]; adressdaten[0].x=7; adressdaten[0].adr_eingeben(); adressdaten[0].adr_schreiben();
}
//Anlegen einer Klasse
//Definition der Methoden
//Hauptfunktion
//Anlegen eines Objektes //Aufruf der Methoden
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 110 Objektorientierter Ansatz
5.4 Konstruktoren und Destruktoren
Jedes mit Hilfe einer Vereinbarung neu geschaffene Objekt wird als Instanz der Klasse
bezeichnet.
Der Aufbau einer solchen Instanz wird mit Hilfe eines Konstruktors und die Entfernung
der Instanz mit einem Destruktor (in C++: automatisch beim Aufruf der Klasse) vorge-
nommen.
Konstruktoren und Destruktoren
Spezielle Methoden einer Klasse
Konstruktoren heißen genau wie die Klasse
Destruktoren heißen wie die Klasse, jedoch mit dem Zeichen ~(126) vor dem Namen
Konstruktoren:
werden bei Instanzbildung einer Klasse automatisch gerufen
belegen Instanzvariable mit Anfangswerten
Destruktoren:
werden bei Ende der Lebensdauer eines Objektes automatisch gerufen
werden meist benutzt, um Speicherbereiche freizugeben, die über Instanzvariablen
addressiert werden
Konstruktoren/Destruktoren haben keinen Typ, sie liefern keinen Wert
(auch nicht void).
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 111 Objektorientierter Ansatz
Programmausschnitt:
Beispiel in C++: Projekt öffnen
#include <iostream> using namespace std; #include <string> class adressen {
private: string name; string vorname; string strasse; string ort; string telefon; string eMail; public: int x; adressen(); ~adressen(); int adr_eingeben(void); int adr_schreiben(void); int adr_listen(void);
}; //Konstruktor adressen::adressen() {
cout << "Anfangswerte setzen\n"; name = "Nobody"; // bei string vorname = "Nobody"; //bei string cout << name << " " << vorname << endl; } //Destruktor adressen::~adressen() {
cout<<"Freigabe des Speicherbereiches\n"; }
//Datendefinition mit Hilfe von //Datentypen //öffentliche Ganzzahl-Variable x, //Konstruktor //Destruktor //Methodendefinitionen mit Hilfe //von Funktionen //Setzen der Anfangswerte
//Freigabe des Speicherbereiches
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 112 Objektorientierter Ansatz
weiteres Beispiel:
Beispiel in C++: Projekt öffnen
#include <iostream> using namespace std; class Klasse { int wert; public: Klasse() { cout << "Konstruktor 1" << endl; wert = 0; } Klasse(int i) { cout << "Konstruktor 2" << endl; wert = i; } ~Klasse() { cout << "Destruktor" << endl; } }; void main(void) { cout << "Programmstart" << endl; Klasse v1, v2 = 3; cout << "im Hauptblock" << endl; { cout << "im Dummyblock" << endl; Klasse v3, v4 = 99; cout << "verlasse Dummyblock" << endl; } cout << "verlasse Programm" << endl; }
l
//Konstruktor v1, Konstruktor v2 //Dummyblock um Konstruktor zu testen //Dummy Block Beginn //Konstruktor v3, Konstruktor v4 //Destruktor v3, Destruktor v4 //Dummy Block Ende
Im Beispiel wurde eine Klasse namens „Klasse“ erklärt. Sie definiert als Datenwert die Va-
riable x und als Methoden zwei Konstruktoren - Klasse() und Klasse(int i) - und einen De-
struktor - ~Klasse() - . In der Hauptfunktion main werden die Instanzen v1 und v2 mit einer
einfachen Vereinbarung gebildet. Die Instanz v1 wird mit der Standard-Konstruktor-
Methode Klasse() und v2 mit der Konstruktormethode Klasse(int i) initialisiert. Die Initialisie-
rung bedeutet hier nur das Setzen der Variablen wert für v1 auf „0“ und für v2 auf „3“. Man
spricht bei der Erstellung neuer Objekte einer Klasse auch von einer Instanziierung der
Klasse.
v3 und v4 werden im eingeschobenen Dummy-Block zur Klasse „Klasse“ instanziiert.
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 113 Objektorientierter Ansatz
Durch diese Konstruktion wird es möglich, die Arbeit des Destruktors zum Abschluß des
Blockes zu beobachten. Die Zerstörung der Instanzen v1 und v2, die im Hauptblock aufge-
baut wurden, können durch cout nicht sichtbar gemacht werden.
5.5 Vererbung
Die Bildung einer Klasse ist eine für den Programmierer arbeitsintensive Sache, der er viel
Sorgfalt zuwenden muss. Zur Vereinfachung des Aufbaus von Klassen, die mit schon defi-
nierten eine „Ähnlichkeit“ besitzen kann durch die Nutzung der Vererbung etwas verein-
facht werden.
Unter Vererbung versteht man die Möglichkeit, Klassen von anderen Klassen abzulei-
ten. Die abgeleiteten Klassen (Kindklassen) erhalten zunächst alle Elemente der Basis-
klasse (Elternklasse). In der Kindklasse können noch zusätzliche Elemente verein-
bart werden. Voraussetzung dafür ist die Änderung der Zugriffsrechte von private auf
protected in der Elternklasse!!!
Im Kapitel 5.3 wurde eine Klasse „adressen“ definiert. Im folgenden Beispiel werden zwei
Kindklassen - „meine_freunde“ und „kunden“ - dieser Klasse aufgebaut, die neben den
Grundelementen der Basisklasse „adressen“ weitere Elemente definieren:
UML-Darstellung
adr_eingeben()adr_schreiben() adr listen()
namestrasse ort telefon eMail
(adressen)
schreibe_geburtstag() geburtstagsliste()
geburtstag
lieblingsessen
(meine_freunde)
lies_kundennummer()lies_umsatz(int monat)
kundennummer umsatz
(kunden)
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 114 Objektorientierter Ansatz
Programmausschnitt:
Beispiel in C++: Projekt öffnen
class adressen { protected: string name; string vorname; string strasse; string ort; string telefon; string eMail; public: int x; adressen(); ~adressen(); int adr_eingeben(void); int adr_schreiben(void); int adr_listen(void); };
class meine_freunde : public adressen { private: char geburtstag[10]; char lieblingsessen[50]; public: int schreibe_geburtstag(void); int geburtstagsliste(int monat); }; class kunden : public adressen { private: int kundennummer; int umsatz[12]; public: int lies_kundennummer(void); int lies_umsatz(int monat); };
//Basisklasse Adressen
// Aenderung der Zugriffsrechte
//von private auf protected
//Abgeleitete Klasse meine_freunde
//Vererbung der Eigenschaften und
// Funktionen aus Basisklasse adressen
//zusätzliche Eigenschaften
//zusätzliche Funktionen
//Abgeleitete Klasse kunden
//Vererbung der Eigenschaften und
// Funktionen aus Klasse adressen
void main(void)
{ class kunden kd_daten[10];
kd_daten[0].lies_kundennummer(); }
// Anlegen eines Objektes kd_daten
//Zugriff auf Methode lies_kundennummer() //der
abgeleiteten Klasse kunden
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 115 Objektorientierter Ansatz
Der Zusatz „: public adressen“ legt die Elternklasse fest; alle nachfolgenden Deklarationen
gelten zusätzlich. Im Beispiel sehen wir eine sogenannte Einfach-Vererbung, es sind aller-
dings auch Mehrfachvererbungen möglich. Für die abgeleitete Klasse „kunden“ könnte
eine weitere Klasse mit zusätzlichen Elementen definiert werden:
Es ist wohl erkennbar, wie die Vererbungsmethodik dem Programmierer die Arbeit erleich-
tert. Allerdings wird vom Programmierer Kenntnis der verwendeten Basisklassen verlangt.
Gerade bei der Ausbildung von Programmierern ist deshalb die Kenntnisvermittlung zu den
Eigenschaften und Methoden der allgemeinen Basisklassen, die in bekannten Entwick-
lungsumgebungen (Visual C++, Borland C++ Builder, ...) vordefiniert sind, ein wesentlicher
Bestandteil der Wissensvermittlung.
class stammkunden : public kunden { ... }
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 116 Objektorientierter Ansatz
Zusammenfassung des bisherigen Beispiels:
#include <iostream> using namespace std; #include <string> //Basisklasse adressen class adressen { protected: string name; string vorname; string strasse; string ort; string telefon; string eMail; public: int x; adressen(); ~adressen(); int adr_eingeben(void); int adr_schreiben(void); int adr_listen(void); }; //Abgeleitete Klasse meine_freunde class meine_freunde : public adressen { private: string geburtstag; string lieblingsessen; public: int schreibe_geburtstag(void); int geburtstagsliste(int monat); }; //Abgeleitete Klasse kunde class kunden : public adressen { private:
int kundennummer; int umsatz[12]; public:
int lies_kundennummer(void); int lies_umsatz(int monat); }; //Konstruktor adressen::adressen() {cout<<"Anfangswerte setzen\n"; } //Destruktor adressen::~adressen() {cout<<"Freigabe des Speicherbereiches\n"; }
// int adressen::adr_eingeben(void) { cout<<"Name: "; cin >>name; cout<<"Vorname: "; cin >>vorname; return 1; } int adressen::adr_schreiben(void) { cout<<"Name: "; cout <<name<<endl; cout<<"Vorname: "; cout <<voname<<endl; return 1; } int adressen::adr_listen(void) { return 1; } int meine_freunde ::schreibe_geburtstag(void) { adressen:adr_eingeben(); cout<<"Geburtstag: "; cin>>geburtstag; return 1; } int kunden::lies_kundennummer(void) { adressen:adr_eingeben(); int kundennummer; cout<<"Kundennummer: "; cin>>kundennummer; return 1; } void main(void) { class meine_freunde freundedaten[10]; cout<<"Daten der Freunde\n"; freundedaten[0].schreibe_geburtstag(); cout<<"Daten der Kunden\n"; class kunden kd_daten[10]; kd_daten[0].lies_kundennummer(); }
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 117 Objektorientierter Ansatz
5.6 Polymorphie
Mit Hilfe der in C++ möglichen Polymorphie kann erreicht werden, dass gleichnamige
Methoden sich in Eltern- und verschiedenen vererbten Klassen unterschiedlich ver-
halten. Die Polymorphie wird mit Hilfe der sogenannten Überladung realisiert, die virtuelle
Klassenbestandteile benutzt.
Wir betrachten das folgende Beispiel mit Bezug auf die in den bisherigen Kapiteln definier-
ten Basis- und Kindklassen:
class adressen { protected: string name; string vorname; string strasse; string ort; string telefon; string eMail; public: int x; adressen(); ~adressen(); virtual int adr_eingeben(); int adr_schreiben(); int adr_listen(); };
class meine_freunde : public adressen { private: string geburtstag; string lieblingsessen; public: int adr_eingeben(); int geburtstagsliste(int monat); }; int meine_freunde :: adr_eingeben() {adressen:adr_eingeben(); cout<<"Geburtstag: "; cin>>geburtstag; return 1; }
//durch das Schlüsselwort virtual kann diese Methode
in den abgeleiteten Klassen überschrieben werden
//Methode adr_eingeben aus Klasse meine_freunde
//Aufruf der Methode adr_eingeben
//aus Klasse adressen
Beispiel in C++: Projekt öffnen
void main(void) { class meine_freunde freundedaten[10]; cout<<"Daten der Freunde eingeben:"<<endl;
freundedaten[0].adr_eingeben();
}
// Anzahl der meine_freunde-Datensätze festlegen
// Aufruf der Methode adr_eingeben() aus der
//Klasse meine_freunde
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 118 Objektorientierter Ansatz
Die Polymorphie bewirkt durch die unterschiedliche Wirksamkeit von Methoden gleichen
Namens eine uneindeutige Zuordnung zur gewünschten Ausführung. Wie bereits unter 5.3
sichert der Scope-Operator "<Basisklasse> :: <Methodenname>“ die Zuordnung einer
benutzten polymorphen Methode zur Klasse.
Zusammenfassung des bisherigen Beispiels:
#include <iostream> using namespace std; #include <string> // Basisklasse //*********************************************** class adressen { protected: string name; string vorname; string strasse; string ort; string telefon; string eMail; public: int x; adressen(); ~adressen(); virtual int adr_eingeben(); int adr_schreiben(); int adr_listen(); }; //Vererbung der Basisklasse //*********************************************** class meine_freunde : public adressen { private: string geburtstag; string lieblingsessen; public: int adr_eingeben(); int geburtstagsliste(int monat); }; //Konstruktor //********************************************** adressen::adressen() {cout<<"Anfangswerte setzen\n"; } //Destruktor //********************************************** adressen::~adressen() {cout<<"Freigabe des Speicherbereiches\n"; }
//Methoden der Basis-Klasse //********************************************** int adressen::adr_eingeben() { cout<<"Name: "; cin >>name; cout<<"Vorname: "; cin >>vorname; return 1; } int adressen::adr_schreiben() { cout<<"Name: "; cout <<name<<endl; cout<<"Vorname: ";
cout <<vorname<<endl; return 1; } int adressen::adr_listen() { return 1; } //Polymorphie //******************************************** int meine_freunde :: adr_eingeben() { adressen::adr_eingeben(); cout<<"Geburtstag:"; cin>>geburtstag; return 1; } //Hauptfunktion //******************************************** void main(void) { class meine_freunde freundedaten[10]; cout<<"Daten der Freunde eingeben:"<<endl; freundedaten[0].adr_eingeben(); }
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 119 Objektorientierter Ansatz
Das folgende Komplexbeispiel zur OOP stellt noch einmal die behandelte Methodik umfas-send dar.
Beispiel in C++: Projekt öffnenl // Programmbeispiel: "tanken.cpp" // Kostenabrechnung fuer einen Tankwart in C++ // Aus Bd.3 Lernfelder und Lernkompetenzen IT-Ausbildung // Medieninstitut Bremen 1998 S.145-148 #include <iostream> // Standard I/O-Klassen using namespace std; #include <iomanip> // wird fuer setw() gebraucht #include <stdio.h> // fuer getch() #include <stdlib.h> // fuer exit() und system() const int MWSTSATZ = 19; // Mwstsatz in % void linie(int anz) // Eine Linie der Laenge anz ausgeben { for (int i = 0; i < anz; i++) cout << '-'; } //--------------------------------------------------------------------------- class Kraftstoff // Die Klasse "Kraftstoff" vereinbaren { private: double literpreis; char * bezeichnung; public: Kraftstoff() // Konstruktor (default) { literpreis = 0.0; bezeichnung = ""; } Kraftstoff(double lp, char * n) // Konstruktor (mit Parametern) { literpreis = lp; bezeichnung = n; } double ArtPreis() // Funktion Literpreisrueckgabe { return literpreis; } char * ArtName() // Funktion Bezeichnungsrueckgabe { return bezeichnung; } }; // Ende der Klassenvereinbarung "Kraftstoff" //--------------------------------------------------------------------------- class Beleg // Die Klasse "Beleg" vereinbaren { private: double liter; double preis; double mwst; double BruttoFaktor; Kraftstoff art; // Aufbau der Instanz "art" zur Klasse "Kraft-stoff" public: Beleg() // Konstruktor (default) { liter = preis = mwst = 0.0; } void setart(Kraftstoff a) // Die Art des Kraftstoffes festlegen { art = a; } void frgliter() { cout << endl << "Kassenabrechnung fuer Kraftstoff: "
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 120 Objektorientierter Ansatz
<< art.ArtName() << endl << endl << "Bitte Literzahl eingeben: "; cin >> liter; BruttoFaktor = art.ArtPreis()*(MWSTSATZ + 100.0) / 100.0; while (liter <= 0.0 || liter*BruttoFaktor >= 10000.00) { cout << endl << "Maximal " << 9999.99 / BruttoFaktor << " und minimal 0.01 Liter eingeben!" << endl << "Bitte richtige Literzahl eingeben: "; cin >> liter; } mwst = liter * art.ArtPreis() * MWSTSATZ / 100.0; preis = liter * BruttoFaktor; } void zeigan() // zeigt das Ergebnis auf Bildschirm an { cout.precision(2); // 2 Stellen Genauigkeit cout.setf(ios::fixed, ios::floatfield); cout << endl << "Menge" << setw(19) << "Kraftstoff" << setw(8); cout << "MWST" << setw(23) << "Verkaufspreis" << endl; linie(55); cout << endl << setw(6) << liter << " Liter" << " " << art.ArtName(); cout << setw(12) << mwst << " EURO" << setw(15) << preis << " EURO" << endl; } void drucken(); // hier nur Prototyp der Funktion "drucken" }; // Ende der Klassenvereinbarung "Kraftstoff" //--------------------------------------------------------------------------- void Beleg::drucken() // externe Funktionsdeklaration zum internen Prototyp { cout.precision(2); cout.setf(ios::fixed, ios::floatfield); cout << endl << " ------------------------------------ " << endl << "| T A N K S T E L L E |" << endl << "| Fa. Gutbenzin |" << endl << "| Reifenweg 5 |" << endl << "| 14711 Musterort |" << endl << "| ******************* |" << endl << "| * " << art.ArtName() << " * |" << endl << "| * " << setw(8) << liter << " Liter * |" << endl << "| * " << setw(8) << preis << " EURO * |" << endl << "| ******************* |" << endl << "| MWST " << MWSTSATZ << "% " << setw(7) << mwst << " EURO |" << endl << "| |" << endl << "| Wir w" << "\x81" << "nschen Ihnen |" << endl << "| eine gute Fahrt! |" << endl << " ------------------------------------ " << "\n\n Geben Sie eine Taste zur Fortsetzung!" << endl << " __________________________________" << endl; } char menue() // Menue anzeigen und Bedienereingaben liefern { char ein; cout << endl << "Kostenabrechnung fuer einen Tankwart" << endl << endl << endl << " 0 - Ende des Programms " << endl << endl << " 1 - Normalbenzin abrechnen" << endl << " 2 - Superbenzin abrechnen" << endl << " 3 - Diesel abrechnen " << endl << endl << "Ihre Wahl? "; cin >> ein; return ein; } void berechnung(Kraftstoff art) // Funktion zur Kostenberechnnung { Beleg b; // Instanz "b" zur Klasse "Beleg" aufbauen b.setart(art); // Art des Kraftstoffes uebergeben
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 121 Objektorientierter Ansatz
b.frgliter(); // die getankte Menge erfragen
b.zeigan(); // das Berechnungsergebnis anzeigen b.drucken(); // den Beleg drucken } int main() // Hauptfunktion { // Drei Instanzen der Klasse "Kraftstoff" erzeugen und initialisieren Kraftstoff normal(1.47, "Normal"); Kraftstoff super(1.52, "Super "); Kraftstoff diesel(1.32, "Diesel"); char auswahl; while ((auswahl = menue()) != '0') { switch (auswahl) { case '1': berechnung(normal); break; case '2': berechnung(super); break; case '3': berechnung(diesel); break; } getc(stdin); cout << "-------------------------------"; } cout << endl << "Programmende" << endl; return 0; }
C++ objektorientierte Programmierung
Dr. Thiem C++ Konsolenprogrammierung 122 Objektorientierter Ansatz
5.7 Aufgaben zum Kapitel 5
1. Erklären Sie den Unterschied der C++-Anweisungen struct und class!
2. Erklären Sie den Sinn der Konstruktoren und Destruktoren für die Instanzen einer Klas-
se!
3. Welcher Zusatz muss für eine Elementdefinition innerhalb einer Klassendefinition ange-
geben werden, wenn auf das Element von außerhalb dieser Klasse zugegriffen werden
soll?
4. Mit welchem Operator können Sie eine Methode, die aufgerufen werden soll einer In-
stanz zuordnen? Mit welchem Operator können Sie eine polymorphe Methode einer
Klasse zuordnen? Nennen Sie Beispiele!
5. Ordnen Sie die folgenden Begriffe in Objekte und Methoden:
a) Datenbank für gemeldete Einwohner einer Stadt
b) Drucken von Einwohnerlisten für die Wahl
c) Gespeicherte Daten eines Autofahrers in Flensburg
d) Daten der minderjährigen Einwohner
e) Eingeben einer Überweisung am Bankautomaten
f) Ausdrucken eines Kontoauszuges
g) Gespeicherte Kontostände
6. Benutzen Sie die in dem Kapitel definierten Klassen „adressen“ und „kunden“ und ver-
wirklichen Sie die durch Prototyp angedeuteten Methoden innerhalb der Klassen! Schaf-
fen Sie ein arbeitsfähiges Programm dazu!
7. Schaffen Sie eine Klasse für die Bücher einer Bibliothek mit folgenden Angaben zu je-
dem Buch: Lfd.Nummer, Titel, Verfasser, Preis, zur Entleihung zugelassen (j/n), Er-
scheinungsjahr, Verlag, Datum der Aufnahme in die Bibliothek, Anzahl der Exemplare.
Nehmen Sie Methoden zur Erfassung der Daten auf! Entwerfen Sie Methoden, die fol-
gende Angaben ausgeben:
a) Titel und Erscheinungsjahr des Buches, das am längsten in der Bibliothek ist.
b) Titel, Verfasser und Preis des teuersten Buches
c) Titel, Verfasser aller Bücher eines einzugebenden Verlages
8. Titel, Verfasser aller Bücher eines einzugebenden Erscheinungsjahres.
Schaffen Sie eine Kindklasse zu Aufgabe 7 für eine internationale Bibliothek, die zusätz-
lich zur Basisklasse Angaben zur Sprache und zum Erscheinungsland aufnimmt. Neh-
men Sie eine zusätzliche Methode zur Ausgabe mit auf, die alle Bücher einer ge-
wünschten Sprache mit Titel, Verfasser und Herstellungsland ausgibt!