/**************************************************************************/
/* Klaus
Weyell 4.5.2002 */
/* Ein
Programm, das von einer abstrakten Basisklasse "Jabberwocky" */
/* einen
Flugdrachen, einen Feuerdrachen und ein Meeresungeheuer ableitet
*/
/**************************************************************************/
/**************************************************************************/
/* Header
Dateien: */
/* iostream
für cin, cout - string für ein string Datenelement
*/
/* cctype
für die Nutzung der Funktion exit */
/**************************************************************************/
#include<iostream>
#include<string>
#include<cctype>
using namespace std;
/**************************************************************************/
/*
Klasse Jabberwocky */
/* alles
ist public, weil dynamische Speicherverwaltung und
*/
/* Polymorphie
verwendet werden */
/**************************************************************************/
class Jabberwocky //abstrakte Basisklasse
{
public:
string
farbe; //Datenelement
void fauchen( ); //Methoden
void treudoofgucken( );
virtual void angreifen( )=0; //rein virtuell
/*virtual string get_farbe( );
virtual void set_farbe(string);*/
};
/**************************************************************************/
/* Zwei
Hilfsfunktionen: sleep und star */
/* sleep
ermöglicht Pausen im Programmablauf */
/* star
malt Sternchen, um Bildschirmausgaben einzurahmen
*/
/**************************************************************************/
void
sleep(int j)
{
for(int i=0; i<=2000000*j;i++){;}
}
void
star(int y)
{
for(int i=0;i<=y;i++)
{
cout<<"*";
}
}
/**************************************************************************/
/* Methoden
der abstrakten Basisklasse Jabberwocky */
/* */
/* */
/**************************************************************************/
void Jabberwocky::treudoofgucken( )
{
sleep(300);
star(79);
cout<<"you are the BEAST
with the silly look, not me!"<<endl
<<"dont stare
at me, it's YOU!"<<endl;
star(79);
}
void
Jabberwocky::angreifen( )
{
cout<<"On whose behalf
dost thou penetrate my privacy?!"<<endl<<endl;
sleep(400);
cout<<"Hast thou no
manners? Or ask I too much to force thee implement thy
weapons?!"<<endl<<endl;
sleep(400);
cout<<"Thy sweet and humanly
odour excites my hunger!!"<<endl<<endl;
sleep(400);
cout<<"You
die!\a"<<endl<<endl;
sleep(100);
cout<<"crunch, munch,
munch,
munch........."<<endl<<"..........belch!!!"<<endl<<endl;
}
void
Jabberwocky::fauchen( )
{
star(79);
cout<<endl;
cout<<"How could a Digi -
Dragon like me possibly do that, Shakespeare ?!"<<endl;
star(79);
}
/**************************************************************************/
/* public
abgeleitete Klasse Flugdrachen */
/* die
rein virtuelle Methode "angreifen" der abstrakten Basisklasse */
/* muss
in jeder abgeleiteten Klasse erneut deklariert werden.
*/
/**************************************************************************/
class Flugdrachen: public Jabberwocky
{
public:
void fliegen( );
void angreifen( ) //inline Implementierung
{
cout<<"Komm, ";
sleep(180);
cout<<"komm, ";
sleep(200);
cout<<"ich tu dir nichts!"<<endl<<endl; //der gutartige Flugdrachen hat eine
} //proprietaere Angriffsfunktion
};
/****************************************************************************/
/*proprietaere Methode
"fliegen" der Klasse Flugdrachen */
/*proprietaere Methoden von
abgeleiteten Klassen lassen sich nur
ueber ein Downcast: */
/*"static_cast<(Zeiger
auf)abgeleitete Zielklasse *>(Zeigername)->proprietaere methode;"*/
/*
ansprechen. */
/****************************************************************************/
void Flugdrachen::fliegen( )
{
char flieg;
cout<<"Hallo Bastian, ich bin Fuchur, dein Gluecksdrache!"<<endl<<endl
<<"Moechtest du gerne fliegen? j/n"<<endl
<<":\\> ";
cin>>flieg;
if(flieg= ='j'||flieg= ='J')
{
sleep(50);
for(int
z=0;z<=172;z++)
{
cout<<"//";
for(int
x=190;x>0;x--)
{
cout<<"\\";
}
}
cout<<endl<<endl;
sleep(60);
cout<<"Na, Bastian, war das nicht ein schoener Flug?!"<<endl<<endl;
}
}
/**************************************************************************/
/* public
abgeleitete Klasse Feuerdrachen */
/**************************************************************************/
class Feuerdrachen: public Jabberwocky
{
public:
void feuerspucken( )
{
star(79);
cout<<"anyone
else, who wants to get shishkebaped alive here????"<<endl;
sleep(60);
cout<<"No???"<<endl;
sleep(50);
cout<<"Haar,
Haar, Haar(this very typical naughty dragon - laugh, you
know)!"<<endl;
star(79);
}
void angreifen( ){;}//Nicht implementiert, da der böse Feuerdrachen hier Jabberwocky beerbt
};
/**************************************************************************/
/* public
abgeleitete Klasse Meeresungeheuer */
/**************************************************************************/
class Meeresungeheuer: public Jabberwocky
{
public:
void schwimmen( )
{
star(79);
sleep(30);
cout<<"1 -
";
sleep(60);
cout<<"2 -
";
sleep(60);
cout<<"3, ins
kuehle Nass!!!"<<endl;
sleep(50);
cout<<"Das macht dem lieben Drachen Spass!"<<endl;
star(79);
}
void angreifen( ){;}//Nicht implementiert, da das böse Meeresungeheuer hier Jabberwocky beerbt
};
/*******************************************************************************/
/*die main Funktion, die die
Funktionalitaet von 3 dynamisch
erzeugten Drachen-Instanzen */
/*
ueber ein einmal geschachteltes switch-case Konstrukt kontrolliert,
indem es ein Menue */
/*
realisiert */
/*******************************************************************************/
void main( )
{
int wahl;
Jabberwocky *ZRudolf, *ZObj1; //Erschaffung von Zeigern
while(true) //Man will das Programm ja nicht //gleich wieder verlassen
{
Marke:
cout<<"\tWelchem Drachen moechten Sie gerne "<<endl<<"\tgegenuebertreten?"<<endl
<<"\t1 Flugdrachen"<<endl
<<"\t2 Feuerdrachen"<<endl
<<"\t3 Meeresungeheuer"<<endl
<<"\t4 Lieber gar keinem! Bibber!....."<<endl<<endl; //Menue1
cin>>wahl;
switch(wahl) //Auswahl1 mit int
{
case 1:
char wahl1;
ZRudolf=new Flugdrachen;
ZObj1=ZRudolf;
ZObj1->farbe="gelb";
cout<<"Erzeugt wurde ein "<<ZObj1->farbe<<"er Flugdrachen"<<endl;
cout<<"Was soll der Flugdrachen machen?"<<endl
<<"(a) fliegen\t (b) fauchen"<<endl
<<"(c) treudoof gucken\t(d) angreifen"<<endl
<<"(e)
zurueck zu Menue1"<<endl<<endl //Menue2
<<":\\> ";
cin>>wahl1;
switch(wahl1) //Auswahl2 mit char
{
case 'a':
static_cast<Flugdrachen*
>(ZRudolf)->fliegen( );
break;
case 'b':
ZRudolf->fauchen(
);
break;
case 'c':
ZRudolf->treudoofgucken(
);
break;
case 'd':
star(79);
static_cast<Flugdrachen*>(ZRudolf)->angreifen( ); //Downcast auf proprietaere Fkt. des Flugdrachens
star(79);
break;
case 'e':
goto Marke;
default:
cout<<"Falsche Eingabe, erzuerne den Drachen nicht!!"<<endl<<endl;
}
break;
case 2:
ZRudolf=new
Feuerdrachen;
ZObj1=ZRudolf;
ZObj1->farbe="rot";
cout<<"Erzeugt wurde ein "<<ZObj1->farbe<<"er Feuerdrachen"<<endl;
cout<<"Was soll der Feuerdrachen machen?"<<endl
<<"(a) Feuer spucken\t (b) fauchen"<<endl
<<"(c) treudoof gucken\t(d) angreifen"<<endl
<<"(e) zurueck zu Menue1"<<endl<<endl
<<":\\> ";
cin>>wahl1;
switch(wahl1)
{
case 'a':
static_cast<Feuerdrachen* >(ZRudolf)->feuerspucken( );
break;
case 'b':
ZRudolf->fauchen(
);
break;
case 'c':
ZRudolf->treudoofgucken(
);
break;
case 'd':
ZRudolf->Jabberwocky::angreifen(
);
break;
case 'e':
goto Marke;
default:
cout<<"Falsche Eingabe, erzuerne den Drachen nicht!!"<<endl<<endl;
}
break;
case 3:
ZRudolf=new
Meeresungeheuer;
ZObj1=ZRudolf;
ZObj1->farbe="gruen";
cout<<"Erzeugt wurde ein "<<ZObj1->farbe<<"es Meeresungeheuer"<<endl;
cout<<"Was soll das Meeresungeheuer machen?"<<endl
<<"(a) schwimmen\t (b) fauchen"<<endl
<<"(c) treudoof gucken\t(d) angreifen"<<endl
<<"(e) zurueck zu Menue1"<<endl<<endl
<<":\\> ";
cin>>wahl1;
switch(wahl1)
{
case 'a':
static_cast<Meeresungeheuer* >(ZRudolf)->schwimmen( );
break;
case 'b':
ZRudolf->fauchen(
);
sleep(50);
ZRudolf->Jabberwocky::angreifen( );
break;
case 'c':
ZRudolf->treudoofgucken(
);
break;
case 'd':
ZRudolf->Jabberwocky::angreifen(
);
break;
case 'e':
goto Marke;
default:
cout<<"Falsche Eingabe, erzuerne den Drachen nicht!!"<<endl<<endl;
}
break;
default:
cout<<"So leicht entkommst du den Drachen nicht!"<<endl<<endl;
break;
case 4:
exit(-1);
}
}
}
Die Objektorientierte Programmierung("OO")
ermöglicht auch, dass eine Klasse von einer anderen Klasse
abgeleitet wird. Die Oberklasse, von der abgeleitet wurde, nennt man dann Basisklasse.
In der
abgeleiteten Klasse finden sich alle Datenelemente und Methoden, die die
Basisklasse hatte wieder, d.h.:
sie wurden vererbt.
Eine abgeleitete Klasse hat immer eine "...ist ein..." - Beziehung zu ihrer Basisklasse.
In der Klassendeklaration hat man die Möglichkeit,
Datenelemente, kurz DE, oder Memberfunktionen, bzw.
Methoden, entweder private(default), protected oder public zu deklarieren. Dies
hat nun auch Auswirkungen
auf die Vererbung dieser Klassen - Mitglieder.
So hat man in der abgeleiteten Klasse auf Elemente, die in der Basisklasse private
deklariert worden
waren, keinen Zugriff mehr, obwohl sie nach wie vor vorhanden sind. Die
Deklaration von Klassenmitgliedern
als protected ist ein Konzept im Hinblick auf die Vererbung, da sie den
Zugriff auf Daten(Eigenschaften)
und Methoden in der abgeleiteten Klasse in der gleichen Art, wie auf eigene(in der Unterklasse
deklarierte) private Elemente
ermöglicht. Alles was public deklariert wurde, bleibt auch nach der
Ableitung public.
Generell bedeutet public ja in der OO -
Programmierung, dass auch globale Funktionen, wie die main - Funktion
freien Zugriff auf das Element haben, worin auch der Sinn der Konvention für
get...( ) und set...( ) - Funktionen
liegt, d.h. habe ich eine private deklarierte Variable i, dann schreibe
ich dazu die public
Funktionen get_i( ) und set_i( ), um auch von main aus an ihren Inhalt zu
kommen, Bsp.:
class X
{
int i;
// i ist implizit private, weil das
der default ist!
public:
void set_i (int init_i)
{ i = init_i;}
int get_i ( ) { return
i; }
};