Trompete implementiert, Klavier leicht angepasst

5_Flugkurve03/code/flugkurve03.cpp

@@ -5,37 +5,38 @@
 using namespace std;
 
 
-Vektor Vektor::mulVektor(const Vektor &vec, const float &skalar){
-  Vektor ergebnis = {vec.x * skalar, vec.y * skalar};
-  return ergebnis;
+void Vektor::mul(const float &skalar){
+    this->x *= skalar;
+    this->y *= skalar;
 }
 
-Vektor addVektor(const Vektor &vec1, const Vektor &vec2) {
-  Vektor erg = {x + x, y + y};
-  return erg;
+void Vektor::add(const Vektor &vec2) {
+    this->x += vec2.x;
+    this->y += vec2.y;
 }
 
-Koerper bewegeKoerper(const Koerper &korp, const Vektor &gesamtkraft,const float &dt) {
-    Koerper erg = {0, {0,0}, {0,0}};
-    // Berechnung der Beschleunigung aus der Kraft
-    const float xBeschleunigung = gesamtkraft.x  / korp.masse;
-    const float yBeschleunigung = gesamtkraft.y  / korp.masse;
-
+void Koerper::bewegen(const Vektor &beschleunigung,const float &dt) {
     // Ermittlung der neuen Geschwindigkeit
-    erg.geschwindigkeit.x = korp.geschwindigkeit.x + dt * xBeschleunigung;
-    erg.geschwindigkeit.y = korp.geschwindigkeit.y + dt * yBeschleunigung;
+    this->geschwindigkeit.x += dt * beschleunigung.x;
+    this->geschwindigkeit.y += dt * beschleunigung.y;
 
     // Ermittlung der neuen Position
-    erg.position.x += korp.position.x + dt * erg.geschwindigkeit.x;
-    erg.position.y += korp.position.y + dt * erg.geschwindigkeit.y;
-    return erg;
+    this->position.x +=  dt * this->geschwindigkeit.x ;
+    this->position.y +=  dt * this->geschwindigkeit.y ;
 }
-
-void ausgabeKoerper(const Koerper &korp){
-    cout << "x = " << korp.position.x << "y = " << korp.position.y;
+  float Koerper::liefereMasse(){
+    return this->masse;
 }
-
-void ausgabeVektor(const Vektor &vec){
-    cout << "x = " << vec.x << endl;
-    cout << "y = " << vec.y << endl;
+Vektor Koerper::lieferePosition(){
+    return this->position;
+}
+  Vektor Koerper::liefereGeschwindigkeit(){
+    return this->geschwindigkeit;
+}
+  string Koerper::text(){
+    string outputX = to_string(this->position.x);
+    string outputY = to_string(this->position.y);
+    stringstream ganzeOut;
+    ganzeOut << "X= " << outputX << " Y= " << outputY;
+    return ganzeOut.str();
 }

5_Flugkurve03/code/flugkurve03.h

@@ -19,20 +19,18 @@ public:
 };
 // Körper:
 class Koerper {
+public:
   float masse; // [kg]
   Vektor position;
   Vektor geschwindigkeit;
-
-public:
   Koerper(float masse, Vektor position, Vektor geschwindigkeit) {
     this->masse = masse;
     this->position = position;
     this->geschwindigkeit = geschwindigkeit;
   };
   float liefereMasse();
-  Koerper bewegeKoerper(const Koerper &korp, const Vektor &gesamtkraft,
-                        const float &dt);
+  void bewegen(const Vektor &gesamtkraft, const float &dt);
   Vektor lieferePosition();
   Vektor liefereGeschwindigkeit();
-  void bewegen(Vektor beschleunigung, float dt);
+  string text();
 };

6_Verkehrsmittel/Klassenplanung.md

@@ -0,0 +1,15 @@
+# Klassen:
+- Verkehrsmittel
+    - Posistion (int x, int y)
+    - bewegen(neue Posistion)
+    - text()
+- Luftfahrzeuge
+    - max. Flughöhe
+    - text()
+- Radfahrzeuge
+    - Anzahl Räder
+    - text()
+- Pkw
+    - Anzahl Türen
+    - text()
+

6_Verkehrsmittel/Luftfahrzeug.h

@@ -0,0 +1,11 @@
+#pragma once
+#include "Verkehrsmittel.h"
+class Luftfahrzeug : public Verkehrsmittel{
+    private:
+        int maxFlughöhe;
+    public:
+        Luftfahrzeug (int maxFlughöhe){
+            this->maxFlughöhe = maxFlughöhe;
+    };
+        std::string text();
+};

6_Verkehrsmittel/PKW.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "Radfahrzeug.h"
+#include "Verkehrsmittel.h"
+
+class PKW : public Radfahrzeug {
+private:
+  int anzahlTüren;
+
+public:
+  PKW(int raeder, int türen) : Radfahrzeug(raeder) { anzahlTüren = türen; }
+  std::string text();
+};

6_Verkehrsmittel/Radfahrzeug.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "Verkehrsmittel.h"
+
+class Radfahrzeug : public Verkehrsmittel {
+private:
+  int anzahlRäder;
+
+public:
+  Radfahrzeug(int räder) { this->anzahlRäder = räder; }
+  std::string text();
+  int getRäder();
+};

6_Verkehrsmittel/Verkehrsmittel.h

@@ -0,0 +1,14 @@
+#pragma once
+#include <string>
+
+class Verkehrsmittel{
+    private:
+        int posX = 0;
+        int posY = 0;
+        int position[2] = {posX,posY};
+    public:
+        void bewege(int x, int y);
+        virtual std::string text();
+        int getX();
+        int getY();
+};

6_Verkehrsmittel/check.cpp

@@ -1,9 +1,10 @@
 #include <cassert>
+#include <iostream>
 #include "Verkehrsmittel.h"
 #include "Luftfahrzeug.h"
 #include "Radfahrzeug.h"
 #include "PKW.h"
-
+using namespace std;
 int main()
 {
 	//Verkehrsmittel

6_Verkehrsmittel/implementierung.cpp

@@ -0,0 +1,60 @@
+#include "Luftfahrzeug.h"
+#include "PKW.h"
+#include "Radfahrzeug.h"
+#include "Verkehrsmittel.h"
+#include <sstream>
+#include <string>
+// Verkehrsmittel - Position x: 0; Position y: 0
+int Verkehrsmittel::getX() { return posX; }
+int Verkehrsmittel::getY() { return posY; }
+int Radfahrzeug::getRäder() { return anzahlRäder; }
+
+void Verkehrsmittel::bewege(int x, int y) {
+  this->posX = x;
+  this->posY = y;
+}
+
+std::string Verkehrsmittel::text() {
+  std::string Xstring = std::to_string(getX());
+  std::string Ystring = std::to_string(getY());
+  std::string Fahrzeug = "Verkehrsmittel";
+  std::stringstream output;
+  output << Fahrzeug << " - " << "Position x: " << Xstring
+         << "; Position y: " << Ystring;
+  return output.str();
+}
+
+std::string Luftfahrzeug::text() {
+  std::string Xstring = std::to_string(getX());
+  std::string Ystring = std::to_string(getY());
+  std::string FlughöheString = std::to_string(maxFlughöhe);
+  std::string Fahrzeug = "Luftfahrzeug";
+  std::stringstream output;
+  output << Fahrzeug << " - " << "Position x: " << Xstring
+         << "; Position y: " << Ystring << "; max. Höhe: " << FlughöheString;
+  return output.str();
+}
+
+std::string Radfahrzeug::text() {
+  std::string Xstring = std::to_string(getX());
+  std::string Ystring = std::to_string(getY());
+  std::string RäderString = std::to_string(anzahlRäder);
+  std::string Fahrzeug = "Radfahrzeug";
+  std::stringstream output;
+  output << Fahrzeug << " - " << "Position x: " << Xstring
+         << "; Position y: " << Ystring << "; Anzahl Räder: " << RäderString;
+  return output.str();
+}
+
+std::string PKW::text() {
+  std::string Xstring = std::to_string(getX());
+  std::string Ystring = std::to_string(getY());
+  std::string Räderstring = std::to_string(getRäder());
+  std::string TürenString = std::to_string(anzahlTüren);
+  std::string Fahrzeug = "PKW";
+  std::stringstream output;
+  output << Fahrzeug << " - " << "Position x: " << Xstring
+         << "; Position y: " << Ystring << "; Anzahl Räder: " << Räderstring
+         << "; Anzahl Türen: " << TürenString;
+  return output.str();
+}

7_Musiker/code/Klavier.cpp

@@ -0,0 +1,6 @@
+#include "Klavier.h"
+#include <iostream>
+using namespace std;
+Klavier::Klavier() { cout << "Konstruktor: Klavier()" << endl; }
+Klavier::~Klavier() { cout << "Destruktor: ~Klavier()" << endl; }
+void Klavier::spielen() { cout << "Klavier klimpert" << endl; }

7_Musiker/code/Klavier.h

@@ -0,0 +1,8 @@
+#pragma once
+#include "Musikinstrument.h"
+class Klavier : Musikinstrument {
+public:
+  Klavier();
+  virtual ~Klavier();
+  virtual void spielen();
+};

7_Musiker/code/Musiker.cpp

@@ -0,0 +1 @@
+#include "Musiker.h"

7_Musiker/code/Musiker.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "Musiker.h"
+#include "Musikinstrument.h"
+#include <string>
+
+class Musiker {
+private:
+  std::string name;
+  const Musikinstrument instrument;
+
+public:
+  Musiker();
+  Musiker(std::string iname);
+  virtual ~Musiker();
+  void weiseInstrumentZU(const Musikinstrument *instrument);
+  void spielen();
+  std::string liefereName();
+};

7_Musiker/code/Musikinstrument.cpp

@@ -0,0 +1,18 @@
+#include "Musikinstrument.h"
+#include <iostream>
+using namespace std;
+
+Musikinstrument::Musikinstrument() {
+  cout << "Konstruktor: Musikinstrument()" << endl;
+}
+Musikinstrument::Musikinstrument(string name) {
+  this->name = name;
+  cout << "Konstruktor: Musikinstrument(string name): " << name << endl;
+}
+Musikinstrument::~Musikinstrument() {
+  cout << "Destruktor: Irgentein Musikinstrument" << endl;
+}
+void Musikinstrument::spielen() {
+  cout << "Irgentein Musikinstrument erklingt irgentwie" << endl;
+}
+string Musikinstrument::liefereName() { return name; }

7_Musiker/code/Musikinstrument.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <string>
+class Musikinstrument {
+private:
+  std::string name;
+
+public:
+  Musikinstrument();
+  Musikinstrument(std::string name);
+  ~Musikinstrument();
+  virtual void spielen();
+  std::string liefereName();
+};

7_Musiker/code/Orchester.cpp

@@ -0,0 +1 @@
+#include "Orchester.h"

7_Musiker/code/Orchester.h

@@ -0,0 +1,14 @@
+#pragma once
+#include "Musiker.h"
+#include <vector>
+
+class Orchester {
+private:
+  std::vector<Musiker> musiker;
+
+public:
+  Orchester();
+  virtual ~Orchester();
+  void spielen();
+  void hinzufügen(Musiker const *musiker);
+};

7_Musiker/code/Trompete.cpp

@@ -0,0 +1,6 @@
+#include "Trompete.h"
+#include <iostream>
+using namespace std;
+Trompete::Trompete() { cout << "Konstruktor: Trompete()" << endl; }
+Trompete::~Trompete() { cout << "Destruktor: ~Trompete()" << endl; }
+void Trompete::spielen() { cout << "Trompete trötet" << endl; }

7_Musiker/code/Trompete.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "Musikinstrument.h"
+
+class Trompete : Musikinstrument {
+public:
+  Trompete();
+  virtual ~Trompete();
+  virtual void spielen() override;
+};