finished all tasks

8_9_Atomkern/code/Atomkern/Atomkern.cpp

@@ -0,0 +1,18 @@
+#include "Atomkern.h"
+
+const Atomkern Atomkern::PROTON  = Atomkern("p", 1, 1);
+const Atomkern Atomkern::NEUTRON = Atomkern("n", 1, 0);
+
+std::ostream& operator << (std::ostream& os, const Atomkern& atomkern)
+{
+    os << atomkern._elementsymbol << "(" << atomkern._massenzahl << "," << atomkern._ordnungszahl << ")";
+    return os;
+}
+
+Atomkern operator * (int factor, const Atomkern& atomkern) 
+{
+    Atomkern ergebnis;
+    ergebnis._ordnungszahl = atomkern._ordnungszahl * factor;
+    ergebnis._massenzahl = atomkern._massenzahl * factor;
+    return ergebnis;
+}

8_9_Atomkern/code/Atomkern/Atomkern.h

@@ -0,0 +1,116 @@
+#pragma once
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <ostream>
+
+class Atomkern
+{
+    public:
+
+    static const Atomkern PROTON;
+    static const Atomkern NEUTRON;
+
+    std::string _elementsymbol;
+    int _ordnungszahl;
+    int _massenzahl;
+
+    
+
+    Atomkern(std::string elementsymbol, int massenzahl, int ordnungszahl)
+    {
+        this->_elementsymbol = elementsymbol;
+        this->_ordnungszahl = ordnungszahl;
+        this->_massenzahl = massenzahl;
+    }
+
+     Atomkern(int massenzahl, int ordnungszahl)
+    {
+        this->_elementsymbol = " ";
+        this->_ordnungszahl = ordnungszahl;
+        this->_massenzahl = massenzahl;
+    }
+
+
+    Atomkern() // Standardatomkern: Wasserstoff
+    {
+        this->_elementsymbol = "H";
+        this->_ordnungszahl = 1;
+        this->_massenzahl = 1;
+    }
+
+    ~Atomkern() {}
+
+    std::string symbol() const
+    {
+        return this->_elementsymbol;
+    }
+
+    int ordnungszahl() const
+    {
+        return this->_ordnungszahl;
+    }
+
+    int massenzahl() const
+    {
+        return this->_massenzahl;
+    }
+
+    Atomkern operator + (const Atomkern& atomkern_to_add) const
+    {
+        Atomkern ergebnis;
+
+        ergebnis._ordnungszahl = this->_ordnungszahl + atomkern_to_add._ordnungszahl;
+        ergebnis._massenzahl = this->_massenzahl + atomkern_to_add._massenzahl;
+
+        return ergebnis;
+    }
+
+    void operator += (const Atomkern& atomkern_to_add)
+    {
+        this->_ordnungszahl += atomkern_to_add._ordnungszahl;
+        this->_massenzahl += atomkern_to_add._massenzahl;
+    }
+
+    Atomkern operator - (const Atomkern& atomkern_to_subtract) const
+    {
+        Atomkern ergebnis;
+
+        ergebnis._ordnungszahl = this->_ordnungszahl - atomkern_to_subtract._ordnungszahl;
+        ergebnis._massenzahl = this->_massenzahl - atomkern_to_subtract._massenzahl;
+
+        return ergebnis;
+    }
+
+    void operator -= (const Atomkern& atomkern_to_subtract)
+    {
+        this->_ordnungszahl -= atomkern_to_subtract._ordnungszahl;
+        this->_massenzahl -= atomkern_to_subtract._massenzahl;
+    }
+
+    Atomkern operator * (const int factor) const
+    {
+        Atomkern ergebnis;
+
+        ergebnis._ordnungszahl = this->_ordnungszahl * factor;
+        ergebnis._massenzahl = this->_massenzahl * factor;
+    
+        return ergebnis;
+    }
+
+
+    int operator == (const Atomkern& atomkern_to_compare) const
+    {
+        if (this->_ordnungszahl == atomkern_to_compare._ordnungszahl && this->_massenzahl == atomkern_to_compare._massenzahl)
+        {
+            return 1;
+        } 
+        else
+        {
+            return 0;
+        }
+    }
+};
+
+std::ostream& operator<<(std::ostream& os, const Atomkern& atomkern);
+Atomkern operator*(int factor, const Atomkern& atomkern);

8_9_Atomkern/code/Reaktor/PrueffolgeReaktor.cpp

@@ -5,7 +5,7 @@
  */
 
 #include "PrueffolgeReaktor.h"
-#include "Atomkern.h"
+#include "../Atomkern/Atomkern.h"
 #include "Reaktor.h"
 using namespace std;
 

8_9_Atomkern/code/Reaktor/Reaktor.h

@@ -0,0 +1,39 @@
+#pragma once
+#include "../Atomkern/Atomkern.h"
+
+class Reaktor
+{
+    int _massenzahl_summe;
+    int _ordnungszahl_summe;
+    
+    public:
+
+    Reaktor() : _massenzahl_summe(0), _ordnungszahl_summe(0) {}
+    ~Reaktor() {}
+
+    Reaktor& operator < (const Atomkern& atomkern_to_add)
+    {
+        this->_massenzahl_summe += atomkern_to_add.massenzahl();
+        this->_ordnungszahl_summe += atomkern_to_add.ordnungszahl();
+        return *this;
+    }
+
+    Reaktor& operator > (const Atomkern& atomkern_to_subtract)
+    {
+        this->_massenzahl_summe -= atomkern_to_subtract.massenzahl();
+        this->_ordnungszahl_summe -= atomkern_to_subtract.ordnungszahl();
+        return *this;
+    }
+
+    void operator ~ ()
+    {
+        this->_massenzahl_summe = 0;
+        this->_ordnungszahl_summe = 0;
+    }
+
+    Atomkern operator * () const
+    {
+        return Atomkern(this->_massenzahl_summe, this->_ordnungszahl_summe);
+    }
+};
+