alle Test laufen durch

2_Flugkurve01/code/flugkurve01.h

@@ -7,7 +7,7 @@ struct Vektor {
 };
 // Körper:
 struct Koerper {
-  float masse = 10; // [kg]
+  float masse; // [kg]
   Vektor position;
   Vektor geschwindigkeit;
 };

3_Summe/code/SchluesselwortConst.txt

@@ -1,9 +1,9 @@
 const float* const wert
 
 Welche Bedeuting haben das erste und zweite const?
-wert ist ein konstanter Zeiger auf ein konstanten float.
 1. const: es ist ein konstanter float
 2. const: es ist ein konstanter zeiger
+
 Welchen Nutzen könnte die Verwendung von const an den beiden Stellen bieten?
 An der 1. Stelle: sichergehen, dass der Wert mit den gearbeitet wird nicht geändert wird
 An der 2. Stelle: sichergehen, dass der Zeiger nicht auf etwas anderes zeigt, womit sich der Wert ändern würde.

4_Flugkurve02/code/check.cpp

@@ -30,6 +30,7 @@ void function_checks() {
 	assert(fabs(koerper.geschwindigkeit.x - 10.7) < 0.1 && "Result must be 10.7");
 	assert(fabs(koerper.geschwindigkeit.y - 9.3) < 0.1 && "Result must be 9.3");
 	assert(fabs(koerper.position.x - 74.9) < 0.1 && "Result must be 74.9");
+    cout << koerper.position.y << endl;
 	assert(fabs(koerper.position.y - 65.1) < 0.1 && "Result must be 65.1");
 	cout << "bewegeKoerper erfolgreich" << endl;
 }

4_Flugkurve02/code/flugkurve02.cpp

@@ -3,36 +3,36 @@
 using namespace std;
 
 Vektor mulVektor(const Vektor &vec, const float &skalar){
-  Vektor ergebnis = {vec.x * num, vec.y * num};
+  Vektor ergebnis = {vec.x * skalar, vec.y * skalar};
   return ergebnis;
 }
 
-Vektor addVektor(Vektor vec1, Vektor vec2) {
+Vektor addVektor(const Vektor &vec1, const Vektor &vec2) {
   Vektor erg = {vec1.x + vec2.x, vec1.y + vec2.y};
   return erg;
 }
 
-Koerper bewegeKoerper(Koerper korp, Vektor gesamtkraft, float dt) {
-
+Koerper bewegeKoerper(const Koerper &korp, const Vektor &gesamtkraft,const float &dt) {
+    Koerper erg = {0, {0,0}, {0,0}};
     // Berechnung der Beschleunigung aus der Kraft
-    float xBeschleunigung = gesamtkraft.x  / korp.masse;
-    float yBeschleunigung = gesamtkraft.y  / korp.masse;
+    const float xBeschleunigung = gesamtkraft.x  / korp.masse;
+    const float yBeschleunigung = gesamtkraft.y  / korp.masse;
 
     // Ermittlung der neuen Geschwindigkeit
-    korp.geschwindigkeit.x += dt * xBeschleunigung;
-    korp.geschwindigkeit.y += dt * yBeschleunigung;
+    erg.geschwindigkeit.x = korp.geschwindigkeit.x + dt * xBeschleunigung;
+    erg.geschwindigkeit.y = korp.geschwindigkeit.y + dt * yBeschleunigung;
 
     // Ermittlung der neuen Position
-    korp.position.x += dt * korp.geschwindigkeit.x;
-    korp.position.y += dt * korp.geschwindigkeit.y;
-    return korp;
+    erg.position.x += korp.position.x + dt * erg.geschwindigkeit.x;
+    erg.position.y += korp.position.y + dt * erg.geschwindigkeit.y;
+    return erg;
 }
 
-void ausgabeKoerper(Koerper korp){
+void ausgabeKoerper(const Koerper &korp){
     cout << "x = " << korp.position.x << "y = " << korp.position.y;
 }
 
-void ausgabeVektor(Vektor vec){
+void ausgabeVektor(const Vektor &vec){
     cout << "x = " << vec.x << endl;
     cout << "y = " << vec.y << endl;
 }

4_Flugkurve02/code/flugkurve02.h

@@ -2,8 +2,8 @@
 
 // Parametrierung der auf den Körper wirkende Kräfte:
 struct Vektor {
-  const float x; // [m/s^2]
-  const float y; // [m/s^2]
+  float x; // [m/s^2]
+  float y; // [m/s^2]
 };
 // Körper:
 struct Koerper {
@@ -12,8 +12,8 @@ struct Koerper {
   Vektor geschwindigkeit;
 };
 
-Vektor addVektor(Vektor vec1, Vektor vec2);
-Vektor mulVektor(Vektor vec, float skalar);
-Koerper bewegeKoerper(Koerper korp, Vektor gesamtkraft, float dt);
-void ausgabeKoerper(Koerper korp);
-void ausgabeVektor(Vektor vec);
+Vektor addVektor(const Vektor &vec1, const Vektor &vec2);
+Vektor mulVektor(const Vektor &vec, const float &skalar);
+Koerper bewegeKoerper(const Koerper &korp, const Vektor &gesamtkraft,const float &dt);
+void ausgabeKoerper(const Koerper &korp);
+void ausgabeVektor(const Vektor &vec);

5_Flugkurve03/code/flugkurve03.cpp

@@ -4,4 +4,39 @@
 #include "flugkurve03.h"
 using namespace std;
 
-//to be implemented
+
+void Vektor::mul(const float &skalar){
+    this->x *= skalar;
+    this->y *= skalar;
+}
+
+void Vektor::add(const Vektor &vec2) {
+    this->x += vec2.x;
+    this->y += vec2.y;
+}
+
+void Koerper::bewegen(const Vektor &beschleunigung,const float &dt) {
+    // Ermittlung der neuen Geschwindigkeit
+    this->geschwindigkeit.x += dt * beschleunigung.x;
+    this->geschwindigkeit.y += dt * beschleunigung.y;
+
+    // Ermittlung der neuen Position
+    this->position.x +=  dt * this->geschwindigkeit.x ;
+    this->position.y +=  dt * this->geschwindigkeit.y ;
+}
+  float Koerper::liefereMasse(){
+    return this->masse;
+}
+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

@@ -1,4 +1,36 @@
 #include <string>
 using namespace std;
 
-// to be defined
+#pragma once
+
+// Parametrierung der auf den Körper wirkende Kräfte:
+class Vektor {
+public:
+  float x; // [m/s^2]
+  float y; // [m/s^2]
+  Vektor() = default;
+  Vektor(float x, float y) {
+    this->x = x;
+    this->y = y;
+  }
+  void add(const Vektor &vec2);
+  void ausgabeVektor(const Vektor &vec);
+  void mul(const float &skalar);
+};
+// Körper:
+class Koerper {
+public:
+  float masse; // [kg]
+  Vektor position;
+  Vektor geschwindigkeit;
+  Koerper(float masse, Vektor position, Vektor geschwindigkeit) {
+    this->masse = masse;
+    this->position = position;
+    this->geschwindigkeit = geschwindigkeit;
+  };
+  float liefereMasse();
+  void bewegen(const Vektor &gesamtkraft, const float &dt);
+  Vektor lieferePosition();
+  Vektor liefereGeschwindigkeit();
+  string text();
+};