Vunic_2_Vererbung.cpp

00001 #include <stdio.h>
00002 #include <math.h>
00003 
00004 enum eckig { ja, nein };
00005 
00006 class Form          // Basisklasse 
00007 {                   
00008                     // In der Basisklasse werden alle gemeinsamen Variablen
00009   protected:          
00010     eckig m_hat_ecken;
00011     float m_umfang;
00012     float m_flaeche;
00013  
00014   public:                   // sowie auch alle gemeinsamen Methoden deklariert
00015     float leseUmfang() { return m_umfang; }
00016     float leseFlaeche() { return m_flaeche; }
00017 
00018     Form(eckig hat_ecken);
00019 };
00020 
00021 Form::Form(eckig ecken) {   // im Konstruktor werden gem. Variablen initialisiert
00022     m_hat_ecken = ecken;
00023     m_umfang = 0;
00024     m_flaeche = 0;
00025 };
00026 
00027 class Kreis : public Form { // Hier wird eine von Form abgeleitete Klasse Kreis deklariert
00028     
00029   protected:                // Zugriffschutz protected bedeutet, dass abgeleitete 
00030                             // Klassen ebenfalls zugreifen können.
00031     float m_radius;
00032     
00033   public:                   
00034     float leseUmfang();
00035     float leseFlaeche();
00036     
00037     Kreis(float radius);    // Neuer Konstruktor erfordert nur den radius 
00038 };
00039 
00040 
00041 class Rechteck : public Form { 
00042     
00043     //Rechteck benötigt neue Membervariablen
00044   protected:     
00045     float seite_a;
00046     float seite_b;
00047     
00048   public:                   
00049     float leseUmfang();
00050     float leseFlaeche();
00051     
00052     Rechteck(float a, float b);    
00053 };
00054 
00055 Rechteck::Rechteck(float a, float b) : Form(ja) {
00056     seite_a = a;
00057     seite_b = b;
00058     
00059     //Umfang und Flaeche werden mit dem Protected Variablen
00060     //der Unterklasse Rechteck ausgerechnet
00061     m_umfang = (2*a) + (2*b);
00062     m_flaeche = a*b;
00063 };
00064 
00065 
00066 Kreis::Kreis(float radius) : Form(nein) {
00067     // Im Konstruktor werden gleich die Membervariablen initialisiert
00068     
00069     // Über den radius werden Umfang und Fläche berechnet. 
00070     m_umfang = 2 * radius * M_PI;  // Die Konstante M_PI ist in math.h definiert
00071     m_flaeche = radius * radius * M_PI;
00072 };
00073 
00074 float Kreis::leseUmfang() {
00075                                 // hier ist keine Änderung der Funktion nötig,
00076                                 // daher wird die Funktion der Basisklasse aufger.
00077     return m_umfang; 
00078 }
00079 
00080 float Kreis::leseFlaeche(){
00081     return m_flaeche;
00082 }
00083 
00084 
00085 float Rechteck::leseUmfang(){  
00086     return m_umfang;
00087 }
00088 float Rechteck::leseFlaeche(){
00089     return m_flaeche;
00090 }
00091 
00092 
00093 
00094 int main()
00095 {
00096     printf("Wir arbeiten nun mit abgeleiteten Klassen!\n");
00097     printf("Nun wird ein Objekt kr der Klasse Kreis erzeugt!\n");
00098     Kreis kr(1.0);
00099     Rechteck re(2.0, 3.0);
00100     
00101     float um = kr.leseUmfang();
00102     
00103     float umf = re.leseUmfang();
00104     
00105     
00106     float fl = re.leseFlaeche();
00107     
00108     printf("Der Umfang des Kreis beträgt: %f\n", um);
00109     printf("Der Umfang des Rechtecks beträgt: %f\n", umf);
00110     printf("Die Flaeche des Rechtecks beträgt: %f\n", fl);
00111     return 0;
00112 }