//classes.h
#ifndef CLASSES_H
#define CLASSES_H


#include <iostream>
using std::cout;


class Manager
{
    //Variables
private:
    int m_detector;


    //Get & Set
public:
    int GetDetector()
    {
        return m_detector;
    }


    //Constructors & Destructors
public:
    Manager()
    {
        m_detector = 0;
    }
    ~Manager()
    {
    }


    //Methods
public:
    void AssociateDetector(int** p2DetectorAssociation)
    {
        *p2DetectorAssociation = &m_detector;
    }
};


/*abstract*/ class Visualizer
{
    //Constructors & Destructors
public:
    Visualizer()=0;


        //Methods
public:
    static void Visualize(int value)
    {
        cout << "Integer value: " << value << std::endl;
    }
};


class ProcessorA
{
    //Variables
private:
    int* m_pDetector;


    //Get & Set
public:
    void SetPDetector(int* pDetector)
    {
        m_pDetector = pDetector;
    }


    //Constructors & Destructors
public:
    ProcessorA()
    {
        m_pDetector = NULL;
    }
    ~ProcessorA()
    {
    }


    //Methods
public:
    void ChangeValue(int newValue)
    {
        *m_pDetector = newValue * newValue;
    }
};


class ProcessorB
{
    //Variables
private:
    int* m_pDetector;


    //Get & Set
public:
    void SetPDetector(int* pDetector)
    {
        m_pDetector = pDetector;
    }


    //Constructors & Destructors
public:
    ProcessorB()
    {
        m_pDetector = NULL;
    }
    ~ProcessorB()
    {
    }


    //Methods
public:
    void ChangeValue(int newValue)
    {
        *m_pDetector = newValue + newValue;
    }
};


#endif


////////////////////////////////////////////////////////////////////////////
//main.cpp
#include "classes.h"


void main()
{
    int** detector = new int*;
    Manager manager;
    ProcessorA processorA;
    ProcessorB processorB;


    manager.AssociateDetector(detector);
    processorA.SetPDetector(*detector);
    processorB.SetPDetector(*detector);

    processorA.ChangeValue(5);
    Visualizer::Visualize(manager.GetDetector());
}

//ich erstelle einen integer x
int x = 5;
//ich erstelle ein pointer auf einen integer
int* pointerToX;


//da der pointer die adresse auf einen integer enthält hole ich mir mit &
//die adresse auf x und weise sie pointerToX zu
pointerToX = &x;


//das würde mir die adresse von x ausgeben also irgend so
//ne zahl wie 6362732
cout << pointerToX;


//wenn ich aber den wert von x will muss ich den pointer dereferenzieren
//das gibt mir jetzt den wert 5 aus
cout << *pointerToX;

for(int i=0; i<n; i++)
{
       bool primZahl = true;


       for(int j=2; j<zahl; j++)
       {
          if(zahl % j == 0)
         {
             primZahl = false;
             break;
         }
     }
     if(primZahl == true)
     {
          cout << "Primzahl: " << i << "\n";
     }
     else
     {
          cout << "Keine Primzahl: " << i << "\n";
     }
 }

#include <iostream>
  #include <windows.h>
  #include <math.h>

  //wir verwenden cout und cin für ein und ausgabe, das sind 2 funktionen in der std
  //was eine standardbibliothek mit klassen und funktionen ist für c++, damit wir
  //wenn wir schreiben dass wir std::cout verwenden können wir einfach etwas mit
  //cout << "text"; ausgeben im programm, ansonstne müssten wir immer dem compiler
  //sagen dass cout in der std ist und über std::cout << "text"; was ausgeben
  using std::cout;
  using std::cin;

  //bevor wir irgendwas machen werden wir mal 3 funktionen deklarieren
  //die benutzt werden um den druchschnitt, median und stdabweichung
  //auszurechnen, sie geben alle einen float, also gleitkommazahl zurück
  //die eben den zb bei der median fkt den median zurückliefert und alle 3
  //bekommen erstmal das array mit den zahlen mit und dann einen integer
  //der angibt wie viele zahlen in dem array stehen die uns interessieren
  //die funktionen werden hier erstmal nur deklarieren, wir sagen dem compiler also
  //hey es gibt sie, damit er nicht verwirrt ist wenn er sie in der main() findet,
  //was drinsteht, also die definition machen wir erst nach der main(), wir könnten
  //sie aber auch gleich jetzt definieren.... ist egal
  //oh ja, und wir wollen auch nicht dass die funktionen unsere paramter verpfuschen
  //indem sie die werte ändern da wir sie ja nach dem aufruf von average noch für median
  //usw brauchen also sagen wir dass die parameter const also konstant sind, sie können
  //also nicht verändert werden, so, was das soll? wir schreiben die funktionen ja selber
  //und wenn wir die parameter nicht verändern wollen dann machen wir es nicht wozu also
  //so ein const davorschreiben... tja.. so ne programmiereigenart, ich machs eigentich nie
  //aber hier mal um das konzept zu zeigen, man sollte es machen, oh und noch etwas
  //funktionsnamen bitte immer mit großem anfangsbuchstaben und variablennamen mit kleinem
  //anfangsbuchstaben, ich tu immer ein kleines a am anfang bei funktionsparametern hin was
  //für attribute steht, also aDasIstEinParameter, und da sieht man gleich noch ne stildings
  //keinsolchenvariablenoderfunktionsnamenschreiben wenn dann SolcheFunktionsNamenZumBeispiel
  //oder dasIstEineVariablenName variablennamen -.-
  float Average(const int aNumbers[], const int aNumbersToProcess);
  float Median(const int aNumbers[], const int aNumbersToProcess);
  float Deviation(const int aNumbers[], const int aNumbersToProcess);

  void main()
  {
      //erstmal brauchen wir ein array das 50 zahlen halten kann
      //wir erstellen dafür zuerst mal ne variable der wir sagen
      //wie groß unser array wird, wenn wir die größe nämlich auf
      //60 ändern möchten müssen wir nicht überall im ganzen programm
      //50 auf 60 ändern sondern nur einmal die zuweisung von numbersLength
      //die länge bleibt auch immer gleich also ist es eine const variable
      //einmal zugewiesen behält sie immer denselben wert
      const int numbersLength = 50;

      //jetzt erstellen wir ein int array mit der größe von numbersLength
      //nachdem wir das array erstellt haben steht in jedem element 0 drin
      //das ist bei c++ default mäßig so bei "normalen" variablen wie int
      int numbers[numbersLength];

      //und alles was zu tun bleibt ist zahlen einzulesen, falls ihr nicht
      //mit for schleifen vertraut seit, die schleife setzt eine variable i
      //und weist ihr ganz am anfang 0 zu, wie in einer while schleife wird
      //zuerst geschaut ob die bedingung stimmt und nachdem die schleife einmal
      //durchlaufen wurde wird i++ ausgeführt, also i um 1 erhöht, im prinzip
      //ist es eine kurzschreibweise für
      /*
      int i=0;
      while(i < numbersLength)
      {
          //TODO

          i = i + 1;
      }
      */

      int i;
      for(i=0; i<numbersLength; i++)
      {
          cout << "Zahl " << i << " eingeben - ";
          cin >> numbers[i];
          //wenn die zahl an der stelle an der wir gerade eben eingelesen haben eine 0
          //ist kommen wir in das if rein
          if(numbers[i] == 0)
          {
              //und hier ist etwas das ihr vielleicht nicht kennen werdet, ein break ist
              //nen sehr praktisches keyword welches bedingungslos wenn es erreicht wird
              //die schleife in der es gerade ist beendet, wird das break also ausgeführt
              //sind wir an der mit dem X markierten stelle weiter unten
              break;
          }
      }

      // - X - und hier kommen wir hin wenn das break ausgeführt wurde oder die maximale
      // anzahl an zahlen eingelesen wurde, ok, da unser zähler (i) immer schön mitgezählt
      // hat steht jetzt in i drinnen wieviele zahlen das array enthält, alles was jetzt noch zu tun ist
      // ist die 3 funktionen aufzurufen die uns unseren median und all den mist ausrechnen

      //bevor wir das tun schauen wir aber überhaupt erst ob der benutzer nicht gleich am anfang eine 0
      //eingegeben hat, dann ist der zähler nämlich auf 0 und über 0 elemente können wir keinen durchschnitt
      //oder so bilden, sollte das der fall sein sagen wir dass wir keine eingabedaten haben und mit return
      //beenden wir die main() funktion und somit das programm
      if(i == 0)
      {
          cout << "Keine Zahlen eingegeben";
          return;
      }

      //und wenn wir hier sind dann ist i mindestens 1

      float average;
      float median;
      float deviation;

      average = Average(numbers, i);
      median = Median(numbers, i);
      deviation = Deviation(numbers, i);

      cout << "\n\nDurchschnitt: " << average << "\nMedian: " << median << "\nStandardabweichung: " << deviation << "\n";
  }

  //so und da definieren wir erstmal die durchschnittsfunktion
  float Average(const int aNumbers[], const int aNumbersToProcess)
  {
      float average = 0;

      //was die for schleife hier macht sollte jetzt klar sein
      //aber halt nochmal zur wiederholung, wir fangen bei 0 an
      //machen solange weiter bis wir den wert erreicht haben der
      //in aNumbersToProcess drin steht und i wird _nach_ jedem
      //schleifendurchlauf um 1 erhöht, was noch anzumerken ist
      //vorher haben wir int i; deklariert und in der schleife
      //geschrieben for(i = 0; ...) jetzt schreiben wir direkt
      //for(int i = 0; ...) das heißt wir definieren i in der for
      //schleife, der clou dabei ist dass sobald die for schleife
      //aus ist, der compiler das i nicht mehr kennt, es ist wenn
      //wir es in dem for mit for(int i = 0; ..) definieren nur innerhlab
      //der for schleife gültig.. k
      for(int i=0; i<aNumbersToProcess; i++)
      {
          //wir missbrauchen die variable für den durchschnitt erstmal um
          //die summe über alle elemente aus aNumbers zu bilden, falls ihr
          //+= nicht kennt, es ist eine kurzschreibweise, wenn ich hab
          //x += y; heißt das x = x + y; ähnlich wie i++; gleich i = i + 1; ist
          //ich könnte natürlich auch schreiben i += 1; das ganze geht auch mit
          // -= *= und /= für minusrechnen, multiplizieren und das vierte, es gibt auch
          // ein -- für i--; also i = i - 1; nur zur ergänzung, allerdings gibt es kein **
          //für i**; irgendwie... i = i²;... ok vergessen wir das mal, also hier bilden
          //wir die summe über alle elemente in aNumbers indem wir es in der schleife durchlaufen
          //und immer den wert drin drinsteht zu average dazuaddieren
          average += aNumbers[i];
      }

      //jetzt wo wir fertig sind haben wir unsere summe über alle elemente die in average drin steht
      //so, angenommen unser array enthielt die elemente 1, 2, 3, 4, 5, 0, 0, 0, ... 0
      //wieso sind da so viele nullen hinten dran?, wir dürfen nicht vergessen, das array ist immer
      //noch 50 integer lang, wir haben nach der 5 die eingabe mit 0 beendet aber dahinter stehen
      //trotzdem immer noch lauter 0llen, allerdings sagt uns aNumbersToProcess das wir als parameter
      //übergeben haben dass uns nur die ersten 5 elemente interessieren, also bilden wir einfach den
      //durchschnitt mit unserer kurzschreibweise average /= aNumbersToProcess; was heißt
      // average = average / aNumbersToProcess;
      average /= aNumbersToProcess;

      //ganz zum schluss geben wir den durchschnitt als rückgabewert der funktion zurück
      return average;
  }

  //und dann kommt der median, ich hab in wikipedia nageschaut da steht der median ist von nem
  //sortierten array einfach das mittlere element, und in eurer angabe steht es wird sortiert sein
  //also müssen wir einfach nur mehr die mitte rausfinden, so einfach? nein der haken ist bei
  // "1, 2, 3" ist es klar was die mitte ist und zwar 2, aber bei "1, 2, 3, 4" ist der median
  // (2 + 3) / 2 also der durchschnitt der mittleren beiden elemente, aber es ist trotzdem leicht
  float Median(const int aNumbers[], const int aNumbersToProcess)
  {
      //so und hier lernen wir nen neuen operator kennen falls ihr den nicht eh schon kennt %
      //der % (modulo) operator schaut wieviel rest zurückbleibt wenn ich eine zahl durch x teile
      //also 10 % 3 ergibt 1 (3*3 ist 9 und 1 rest auf 10), oder 50 % 26 ergibt 24 (26 geht in 50 1 mal
      //und es bleibt 24 rest, mit dem operator können wir also ganz einfach rausfinden ob wir ne richtige
      //mitte haben oder den druchschnitt über die 2 mittleren elemente bilden müssen, wenn ich nämlich
      //5 elemente habe und 5%2 rechne kommt 1 raus, dh die zahl ist ungerade, und bei 10%2 kommt 0 raus
      //also ist sie gerade

      //ist unsere zahl ungerade?
      if(aNumbersToProcess % 2 == 1)
      {
          //wenn ja dann sagen wir mal es sind 9 elemente, wir rechnen einfach 9 / 2, das ergibt 4.5, wir
          //lassen das 0.5 wegfallen und 4 ist unsere element in der mitte, hier das ganze grafisch untermalt
          //dabei nicht vergessen das ein array von 0 - n durchnumeriert wird und nicht von 1 bis n, und a-i
          //sind unsere elemente
          // 0 1 2 3 4 5 6 7 8
          // a b d c e f g h i
          //wie lasse ich den rest wegfallen? ein int kann nur ganze zahlen speichern, wenn ich 9/2 rechne
          //wird nicht gerundet sondern die nachkommastelle fällt immer weg

          //das hier kann vielleicht etwas verwirrend sein, also man könnte es in einzelschritte aufteilen
          /*
          int middle;

          middle = (int)(aNumbersToProcess/2);

          return aNumbers[middle];
          */
          //oder wir hauen es einfach gleich in das return statement rein, falls ihr das (int) nicht kennt, das
          //ist ein cast, ein cast wandelt einen variabentyp in einen anderen um, wenn wir 9 / 2 rechnen zb kommt
          //ein double dabei raus (nicht float, wenn ihr 5.323 schreibt ist es für den compiler ein double außer
          //ihr sagt was anderes), in c++ ist es egal weil der compiler das eh automatisch sieht dass ihr die 4.5
          //einem int zuweist und er lässt die .5 wegfallen aber andere programmiersprachen wie c# meckern da zb
          //herum also hab ichs drin gelassen wegen typensicherheit blabla... schöner programmierstil, und da wir
          //integer in aNumbers haben casten wir auch auf nen float da der rückgabewert float ist
          return (float)aNumbers[(int)(aNumbersToProcess/2)];
      }
      else
      {
          //und wenn wir eine gerade anzahl an elementen haben zb 4 ist das "zweite mittlere element" 4/2, also
          //element 2, das c, und das erste mittlere element 4/2 - 1, also das b
          // 0 1 2 3
          // a b c d
          //wenn wir uns das überlegen geht das auch immer, 6 elemente, das erste mittlere ist 6/2 - 1 = 2 und das
          //zweite 6/2 = 3, also in dem fall wäre element 2 die 4 und element 3 die 6, und der median ist (4+6) / 2
          // 0 1 2 3 4 5
          // 1 2 4 6 9 9

          //weil wir nicht das nicht wieder in 10 zeilen schreiben wollen packen wir alles gleich in eine
          //aber zur veranschaulichung, es ist im prinzip das
          /*int middleElement1Position = aNumbersToProcess/2 - 1;
            int middleElement2Position = aNumbersToProcess/2;

            int middleElement1 = aNumbers[middleElement1Position];
            int middleElement2 = aNumbers[middleElement2Position];

            float median = (float) ( (middleElement1 + middleElement2) / 2 );
            return median;
          */
          return (float)( (aNumbers[aNumbersToProcess/2 - 1] + aNumbers[aNumbersToProcess/2]) / 2 );
      }
  }

  //ok und als aller letztes die standardabweichung... ja... ok google sagt
  //"standardabweichung: die summe aller quadrierten abweichungen der einzelnen
  //messerwerte vom mittelwert, dividiert durch die anzahl der messwerte, ergibt
  //die variaz (aha die variaz.. ok), die standardabweichung ist die pos wurzel der
  //variaz
  //so toll, da brauchen wir also wurzeln und so, aber es ist trotzdem nicht schwer
  float Deviation(const int aNumbers[], const int aNumbersToProcess)
  {
      float variance = 0;

      //so, zuerst müssen wir die summe aller quadrierten abweichungen bilden, also bevor
      //wir anfangen kurz n beispiel so wie ich das verstanden habe, wenn unsere elemente
      //1, 2, 3, 4, 5 sind dann ist der durchschnitt (1+2+3+4+5)/5 = 3, die varianz ist
      // ( (1-3)² + (2-3)² + (3-3)² + (4-3)³ + (5-3)² ) / 5, und die standardabweichung ist
      //dann die wurzel aus der varianz, also zuerst rechnen wir uns den durchschnitt aus
      //was wir ja von unserer durchschnittfunktion übernehmen lassen können

      //wir definieren einfach ne neue variable wo wir den durchschnitt reinspeichern, der
      //rückgabe wert von Average ist einfach ein float mit dem durchschnitt deswegen können
      //wir das einfach so schreiben als wenn die funktion ein wert wäre, in wirklichkeit
      //wird die funktion ausgeführt und der rückgabewert wird dann average zugewiesen
      float average = Average(aNumbers, aNumbersToProcess);

      //jetzt wo wir den durchschnitt haben bilden wir die varianz
      for(int i=0; i<aNumbersToProcess; i++)
      {
          //so, das ganze += und for zeug kennen wir bereits, pow ist jetzt eine funktion
          //die in der math.h drin ist und wir verwenden sie genauso wie printf zb, der
          //erste parameter ist die zahl selbst, und der zweite die potenz, wir wollen
          //(aNumbers[i] - average) also die abweichung quadrieren also ist das der erste
          //parameter, der zweite ist 2 weil wir es hoch 2 nehmen wollen, wir könnten natürlich
          //auch schreiben variance += (aNumbers[i] - average) * (aNumbers[i] - average); aber
          //wenn sich schon jemand anders die mühe gemacht hat die pow funktion zu schreiben
          //benutzen wir sie gleich, und wir casten den ersten parameter der fkt auf einen float
          //da wenn wir aNumbers[i] (ist ein int) - average (ist ein float) rechnen kommt glaube ich
          //dabei ein double raus, bin mir aber nicht sicher und pow gibt wenn es (double, int)
          //reinbekommt nen double zurück, wir könenn also entweder
          //variance += (float)pow((aNumbers[i] - average), 2); schreiben wo wir den double rückgabe
          //wert auf float zurückcasten oder wir casten gleich den ersten parameter auf nen float
          //ich hoffe ich erzähle hir keinen mist weil ich mir nicht sicher bin ob ein int - float nen
          //double ergibt... aber wie gesagt ist es eigentlich egal weil das in c++ sowieso alles
          //automatisch geht, aber trotzdem, typensicherheit, hoffe das mit dem casten verwirrt nicht so
          variance += pow((float)(aNumbers[i] - average), 2);
      }

      //jetzt müssen wir wie in der angabe von dem varianz zeug den durchschnitt über die abweichungen
      //bilden also dividieren wir die summe der abweichungen durch die anzahl der elemente
      variance /= aNumbersToProcess;

      //und am ende hepp, geben wir die wurzel aus der varianz zurück, casten den rückgabewert hier nicht
      //weil die qrt funktion wenn sie nen float reinbekommt und variance ist ja ein float auch nen float
      //rausspuckt, bei pow haben wir als ersten parameter double übergeben und als zweiten einen int, weil
      //wir gerechnet haben (aNumbers[i] - average) numbers ist ein int und average ein float aber wenn 
      return sqrt(variance);
  }

#include <string>
#include <iostream>
#include <sstream>


void StringToFloatMethod1()
{
    //Methode 1
    float aFloat = 20.4324;
    std::ostringstream floatStringHelper;

    floatStringHelper << aFloat;


    std::string floatString = floatStringHelper.str();
    std::cout << floatString;
}

void StringToFloatMethod2()
{
    //Methode 2
    float aFloat = 20.4324;
    char floatStringBuffer[256];


    sprintf(floatStringBuffer, "%f\n", aFloat);


    printf("%f", aFloat);
}