c++ 5 OOP - staff.hs-mittweida.dethiem1/cpp/unterlagen/kap05/theorie05.pdf · C++ objektorientierte...

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



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.



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



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

eMail

(adressen)



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( )



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.



Zusammenfassung des bisherigen Beispiels:


#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



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).



Programmausschnitt:


#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



weiteres Beispiel:


#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.



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)



Programmausschnitt:


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



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 { ... }




#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(); }



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


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



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.


#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(); }



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: "



<< 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



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; }



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!

c++ 5 OOP - staff.hs-mittweida.dethiem1/cpp/unterlagen/kap05/theorie05.pdf · C++ objektorientierte...

Documents

Transcript of c++ 5 OOP - staff.hs-mittweida.dethiem1/cpp/unterlagen/kap05/theorie05.pdf · C++ objektorientierte...