Mesic_Vererbung_1.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     float m_rechteckFlaeche;
00014     float m_rechteckUmfang;
00015 
00016   
00017  
00018   public:                   // sowie auch alle gemeinsamen Methoden deklariert
00019     float leseUmfang() { return m_umfang; }
00020     float leseFlaeche() { return m_flaeche; }
00021     float leseRechteckUmfang() { return m_rechteckUmfang; }
00022     float leseRechteckFlaeche() { return m_rechteckFlaeche; }
00023  
00024   
00025 
00026     Form(eckig hat_ecken);
00027     Form();
00028     };
00029 
00030 Form::Form(eckig ecken) // im Konstruktor werden gem. Variablen initialisiert
00031     {   
00032     m_hat_ecken = ecken;
00033     m_umfang = 0;
00034     m_flaeche = 0;
00035     };
00036 Form::Form()
00037     {
00038     m_rechteckFlaeche=0;
00039     m_rechteckUmfang=0;
00040     }
00041 
00042 class Kreis : public Form { // Hier wird eine von Form abgeleitete Klasse Kreis deklariert
00043     
00044   protected:                // Zugriffschutz protected bedeutet, dass abgeleitete 
00045                             // Klassen ebenfalls zugreifen können.
00046     float m_radius;
00047     
00048   public:                   // alle gemeinsame Methoden
00049     float leseUmfang();
00050     float leseFlaeche();
00051     
00052     Kreis(float radius);  // Neuer Konstruktor erfordert nur den radius 
00053     };
00054 
00055 Kreis::Kreis(float radius) : Form(nein) // Konstruktor
00056     { 
00057     m_umfang = 2 * radius * M_PI;  // Die Konstante M_PI ist in math.h definiert
00058     m_flaeche = radius * radius * M_PI;
00059     };
00060 
00061     float Kreis::leseUmfang() {// hier ist keine Änderung der Funktion nötig,
00062                             // daher wird die Funktion der Basisklasse aufger.
00063     return m_umfang; 
00064     }
00065     float Kreis::leseFlaeche() 
00066     {
00067     return m_flaeche; 
00068     }
00069 
00070 
00071 class Rechteck : public Form { 
00072     
00073   protected:               
00074     float m_seiteA;
00075     float m_seiteB;
00076     float m_seitea;
00077     float m_quadratUmfang;
00078     float m_quadratFlaeche;
00079  
00080     
00081   public:                   
00082     float leseRechteckFlaeche();   // alle gemeinsame Methoden
00083     float leseRechteckUmfang();
00084     float leseQuadratUmfang() { return m_quadratUmfang; }
00085     float leseQuadratFlaeche() { return m_quadratFlaeche; }
00086 
00087     
00088     Rechteck(float seiteA, float seiteB); // Deklaration des Konstruktors
00089     Rechteck();                          // Deklaration des Konstruktors
00090 
00091     };
00092 
00093  
00094 Rechteck::Rechteck(float seiteA,float seiteB) : Form(ja)  // Konstruktor
00095     {
00096     m_rechteckUmfang = 2 * seiteA + 2 * seiteB;  
00097     m_rechteckFlaeche = seiteA * seiteB;
00098     };
00099 
00100 Rechteck::Rechteck()   // Konstruktor
00101     {
00102     m_quadratUmfang=0;
00103     m_quadratFlaeche=0;
00104     };
00105 
00106     float Rechteck::leseRechteckUmfang()
00107     {
00108     return m_rechteckUmfang; 
00109     }
00110     float Rechteck::leseRechteckFlaeche() 
00111     {
00112     return m_rechteckFlaeche; 
00113     }
00114     
00115     
00116 
00117 
00118 
00119 class Quadrat : public Rechteck   //Deklaration der Klasse Quadrat
00120     
00121     {
00122     protected:               
00123     float m_seitea;
00124  
00125     public:                   
00126     float leseQuadratUmfang();
00127     float leseQuadratFlaeche();
00128     
00129     Quadrat(float seitea); // Deklaration des Konstruktors
00130     
00131     };
00132 
00133 Quadrat::Quadrat(float seitea) : Rechteck() // Konstruktor
00134     {
00135     m_quadratFlaeche=seitea*seitea;
00136     m_quadratUmfang= 4 * seitea;
00137     };
00138 
00139   
00140     float Quadrat::leseQuadratUmfang()
00141     {
00142     return m_quadratUmfang; 
00143     }
00144     float Quadrat::leseQuadratFlaeche() 
00145     {
00146     return m_quadratFlaeche; 
00147     }
00148 
00149 
00150 
00151 
00152 
00153 int main()
00154 {
00155     printf("Wir arbeiten nun mit abgeleiteten Klassen!\n");
00156     printf("Nun wird ein Objekt kr der Klasse Kreis erzeugt!\n");
00157     Kreis kr(1.0);
00158     Rechteck re(2.0,3.0);
00159     Quadrat qu(5.0);
00160     
00161     float um = kr.leseUmfang();
00162     float fl = kr.leseFlaeche();
00163     
00164     float reUm = re.leseRechteckUmfang();
00165     float reFl = re.leseRechteckFlaeche();
00166     
00167     float quUm = qu.leseQuadratUmfang();
00168     float quFl = qu.leseQuadratFlaeche();
00169     
00170     printf("Der Umfang des Kreis beträgt: %f\n", um);
00171     printf("Die Flaeche des Kreis beträgt: %f\n", fl);
00172     
00173     printf("Der Umfang des Rechtecks beträgt: %f\n", reUm);
00174     printf("Die Flaeche des Rechtecks beträgt: %f\n", reFl);
00175     
00176     printf("Der Umfang des Quadrats beträgt: %f\n", quUm);
00177     printf("Die Flaeche des Quadrats beträgt: %f\n", quFl);
00178     return 0;
00179 }
00180 
00181 
00182 
00183