Revision 0:bedc26f35995, committed 2020-04-29

Comitter:

haunsi

Date:

Wed Apr 29 11:18:41 2020 +0000

Commit message:

Namespace_Vererbung_final

Changed in this revision

diff -r 000000000000 -r bedc26f35995 Harg_1_Klassen_Namespace.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Harg_1_Klassen_Namespace.cpp	Wed Apr 29 11:18:41 2020 +0000
@@ -0,0 +1,60 @@
+#include <stdio.h>
+#include <iostream>
+ 
+enum eckig {ja,nein};
+
+namespace Harg  //gibt den namespace an unter dem gearbeitet wird
+{
+    class Kreis         
+    {
+        //Zugriff nur über Member-Funktionen
+        private:          
+        float m_radius;
+        eckig hat_ecken; //für die Übergabe, ob rund oder eckig
+        
+        public:          
+        float berechneUmfang();
+        float berechneFlaeche();
+        char rundodereckig(); 
+ 
+        Kreis(float radius, eckig ecken);
+};
+ 
+    Kreis::Kreis(float radius, eckig ecken) 
+    {
+        m_radius = radius;
+        hat_ecken = ecken;
+    }    
+ 
+    float Kreis::berechneUmfang() 
+    {
+        return (m_radius * m_radius * 3.1415);
+    }
+ 
+    char Kreis::rundodereckig() //Funktionsdefinition, ob Ecken oder nicht
+    {
+        if (hat_ecken == 1)
+        {
+            printf("Der Kreis hat keine Ecken.\n");
+            return hat_ecken;
+        }
+        else 
+        {
+            printf("Der Kreis hat Ecken.\n");
+            return hat_ecken;
+        }
+    }
+}
+ 
+int main ()
+{
+  using namespace Harg;
+  Kreis meinKreis(4.0, ja); //Erstellung des Objekts "meinKreis"
+  
+  float umfang = meinKreis.berechneUmfang();
+  char corny = meinKreis.rundodereckig(); 
+  
+  printf ("Der Umfang beträgt: %f m. %d", umfang, corny); //Ausgabe des Umfangs und des Bool-Werts
+ 
+  return 0;
+}
\ No newline at end of file

diff -r 000000000000 -r bedc26f35995 Harg_2_Vererbung.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Harg_2_Vererbung.cpp	Wed Apr 29 11:18:41 2020 +0000
@@ -0,0 +1,102 @@
+#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;
+ 
+  public:                   // sowie auch alle gemeinsamen Methoden deklariert
+    float leseUmfang() { return m_umfang; }
+    float leseFlaeche() { return m_flaeche; }
+
+    Form(eckig hat_ecken);
+};
+
+Form::Form(eckig ecken) {   // im Konstruktor werden gem. Variablen initialisiert
+    m_hat_ecken = ecken;
+    m_umfang = 0;
+    m_flaeche = 0;
+};
+
+class Kreis : public Form // erstellen einer neuen Klasse mit Verweis auf die Basisklasse
+{ 
+    
+  protected:                
+    float m_radius; // eigentlich überflüssig, da nie verwendet
+    
+  public:    // nicht benötigt, da in Form schon ausprogrammiert
+    float leseUmfang() { return m_umfang; } 
+    float leseFlaeche() { return m_flaeche; }
+    
+    Kreis(float radius);    
+};
+
+Kreis::Kreis(float radius) : Form(nein) 
+{
+    m_umfang = 2 * radius * M_PI; 
+    m_flaeche = radius * radius * M_PI;
+};
+
+
+class Rechteck : public Form // erstellen einer neuen Klasse mit Verweis auf die Basisklasse
+{
+    protected:
+     float m_seiteA; // eigentlich überflüssig, da nie verwendet
+     float m_seiteB; // eigentlich überflüssig, da nie verwendet
+
+   public:    
+     float leseUmfang() { return m_umfang; } 
+     float leseFlaeche() { return m_flaeche; }
+    
+    Rechteck(float m_seiteA); // Deklaration des Konstruktors
+    Rechteck(float m_seiteA, float m_seiteB);
+};
+
+// :: gibt die Klassenzugehörigkeit an
+Rechteck::Rechteck(float m_seiteA) : Form(ja){}; // Definition des Konstruktors
+Rechteck::Rechteck(float m_seiteA, float m_seiteB) : Form(ja)
+{
+   m_umfang = 2*m_seiteA + 2*m_seiteB; // Berechnungen
+   m_flaeche = m_seiteA * m_seiteB; 
+};
+
+class Quadrat : public Rechteck // erstellen einer neuen Unterklasse mit Verweis auf die vorherige
+{
+   public:    
+    float leseUmfang() { return m_umfang; } 
+    float leseFlaeche() { return m_flaeche; }
+    
+    Quadrat(float m_seiteA); // Deklaration des Konstruktors
+};
+
+// :: gibt die Klassenzugehörigkeit an
+Quadrat::Quadrat(float m_seiteA) : Rechteck (m_seiteA) // Definition des Konstruktors
+{
+    m_umfang = 4*m_seiteA; // Berechnungen
+    m_flaeche = m_seiteA*m_seiteA;
+};
+
+int main()
+{
+    Kreis kr(1.0);
+    
+    printf("Der Umfang des Kreis beträgt: %f m.\n", kr.leseUmfang());
+    printf("Der Fläche des Kreis beträgt: %f m².\n\n", kr.leseFlaeche());
+    
+    Rechteck rk(2.3,2.6);
+    
+    printf("Der Umfang des Rechtecks beträgt: %f m.\n", rk.leseUmfang());
+    printf("Die Fläche des Rechtecks beträgt: %f m².\n\n", rk.leseFlaeche());
+    
+    Quadrat qu(3.0);
+ 
+    printf("Der Umfang des Quadrats beträgt: %f m.\n", qu.leseUmfang());
+    printf("Der Fläche des Quadrats beträgt: %f m².\n\n", qu.leseFlaeche());
+    return 0;
+}