Diff: Mesic_Vererbung_1.cpp

Revision:

0:f277e7be6723

diff -r 000000000000 -r f277e7be6723 Mesic_Vererbung_1.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Mesic_Vererbung_1.cpp	Wed Mar 25 22:17:56 2020 +0000
@@ -0,0 +1,183 @@
+#include <stdio.h>
+#include <math.h>
+
+enum eckig { ja, nein };
+
+class Form          // Basisklasse 
+    {                   
+                    // In der Basisklasse werden alle gemeinsamen Variablen
+  protected:          
+    eckig m_hat_ecken;
+    float m_umfang;
+    float m_flaeche;
+    float m_rechteckFlaeche;
+    float m_rechteckUmfang;
+
+  
+ 
+  public:                   // sowie auch alle gemeinsamen Methoden deklariert
+    float leseUmfang() { return m_umfang; }
+    float leseFlaeche() { return m_flaeche; }
+    float leseRechteckUmfang() { return m_rechteckUmfang; }
+    float leseRechteckFlaeche() { return m_rechteckFlaeche; }
+ 
+  
+
+    Form(eckig hat_ecken);
+    Form();
+    };
+
+Form::Form(eckig ecken) // im Konstruktor werden gem. Variablen initialisiert
+    {   
+    m_hat_ecken = ecken;
+    m_umfang = 0;
+    m_flaeche = 0;
+    };
+Form::Form()
+    {
+    m_rechteckFlaeche=0;
+    m_rechteckUmfang=0;
+    }
+
+class Kreis : public Form { // Hier wird eine von Form abgeleitete Klasse Kreis deklariert
+    
+  protected:                // Zugriffschutz protected bedeutet, dass abgeleitete 
+                            // Klassen ebenfalls zugreifen können.
+    float m_radius;
+    
+  public:                   // alle gemeinsame Methoden
+    float leseUmfang();
+    float leseFlaeche();
+    
+    Kreis(float radius);  // Neuer Konstruktor erfordert nur den radius 
+    };
+
+Kreis::Kreis(float radius) : Form(nein) // Konstruktor
+    { 
+    m_umfang = 2 * radius * M_PI;  // Die Konstante M_PI ist in math.h definiert
+    m_flaeche = radius * radius * M_PI;
+    };
+
+    float Kreis::leseUmfang() {// hier ist keine Änderung der Funktion nötig,
+                            // daher wird die Funktion der Basisklasse aufger.
+    return m_umfang; 
+    }
+    float Kreis::leseFlaeche() 
+    {
+    return m_flaeche; 
+    }
+
+
+class Rechteck : public Form { 
+    
+  protected:               
+    float m_seiteA;
+    float m_seiteB;
+    float m_seitea;
+    float m_quadratUmfang;
+    float m_quadratFlaeche;
+ 
+    
+  public:                   
+    float leseRechteckFlaeche();   // alle gemeinsame Methoden
+    float leseRechteckUmfang();
+    float leseQuadratUmfang() { return m_quadratUmfang; }
+    float leseQuadratFlaeche() { return m_quadratFlaeche; }
+
+    
+    Rechteck(float seiteA, float seiteB); // Deklaration des Konstruktors
+    Rechteck();                          // Deklaration des Konstruktors
+
+    };
+
+ 
+Rechteck::Rechteck(float seiteA,float seiteB) : Form(ja)  // Konstruktor
+    {
+    m_rechteckUmfang = 2 * seiteA + 2 * seiteB;  
+    m_rechteckFlaeche = seiteA * seiteB;
+    };
+
+Rechteck::Rechteck()   // Konstruktor
+    {
+    m_quadratUmfang=0;
+    m_quadratFlaeche=0;
+    };
+
+    float Rechteck::leseRechteckUmfang()
+    {
+    return m_rechteckUmfang; 
+    }
+    float Rechteck::leseRechteckFlaeche() 
+    {
+    return m_rechteckFlaeche; 
+    }
+    
+    
+
+
+
+class Quadrat : public Rechteck   //Deklaration der Klasse Quadrat
+    
+    {
+    protected:               
+    float m_seitea;
+ 
+    public:                   
+    float leseQuadratUmfang();
+    float leseQuadratFlaeche();
+    
+    Quadrat(float seitea); // Deklaration des Konstruktors
+    
+    };
+
+Quadrat::Quadrat(float seitea) : Rechteck() // Konstruktor
+    {
+    m_quadratFlaeche=seitea*seitea;
+    m_quadratUmfang= 4 * seitea;
+    };
+
+  
+    float Quadrat::leseQuadratUmfang()
+    {
+    return m_quadratUmfang; 
+    }
+    float Quadrat::leseQuadratFlaeche() 
+    {
+    return m_quadratFlaeche; 
+    }
+
+
+
+
+
+int main()
+{
+    printf("Wir arbeiten nun mit abgeleiteten Klassen!\n");
+    printf("Nun wird ein Objekt kr der Klasse Kreis erzeugt!\n");
+    Kreis kr(1.0);
+    Rechteck re(2.0,3.0);
+    Quadrat qu(5.0);
+    
+    float um = kr.leseUmfang();
+    float fl = kr.leseFlaeche();
+    
+    float reUm = re.leseRechteckUmfang();
+    float reFl = re.leseRechteckFlaeche();
+    
+    float quUm = qu.leseQuadratUmfang();
+    float quFl = qu.leseQuadratFlaeche();
+    
+    printf("Der Umfang des Kreis beträgt: %f\n", um);
+    printf("Die Flaeche des Kreis beträgt: %f\n", fl);
+    
+    printf("Der Umfang des Rechtecks beträgt: %f\n", reUm);
+    printf("Die Flaeche des Rechtecks beträgt: %f\n", reFl);
+    
+    printf("Der Umfang des Quadrats beträgt: %f\n", quUm);
+    printf("Die Flaeche des Quadrats beträgt: %f\n", quFl);
+    return 0;
+}
+
+
+
+