Classe hinzugefügt

README.md

@@ -1,3 +1,59 @@
 # C-CPP_Practise
 
+
+# Git
+
+
+1. git **stage** ==> Festschreiben der gemachten localen änderungen ohne diese auf den Server zu laden, die Änderungen sind aber beim nächsten commit enthalten
+
+2. git **commit** ==> Schnappschuss der Änderungen die gestaged sind. Änderungen werden auf den Server geladen.
+
+3. git **push**  ==> Senden der lokalen änderungen an den Server
+
+4. git **pull** ==> Holen der Änderungen vom Server und anwenden auf die Lokale Version 
+
+Für den Entwicklungsprozess gibt es immer 3 Branches
+
+- main
+- int (integration)
+- dev (development)
+
+**main** ist immer der Stabile getestete Stand mit Vollversionenn **0**_.XXXy_ ,**1**_.XXXy_ , **2**_.XXXy_, ...
+
+**int** ist für eine Version in der Neuerungen die volle Funktionalität aufweißt, ohne stabilitäts tests, als Kennzeichnung werden 3 Stellen nach dem Punkt nummerisch verwendet _N.**001**y_, _N.**002**y_, _N.**003**y_, ...
+
+**dev** ist für das hinzufügen neuer funktionen ohne funktions und stabilitäts garantie und hat als kennzeichnung einen Kleinbuchstaben _N.XXX_**a**, _N.XXX_**b**, _N.XXX_**c**, ...
+
+## Änderungen in ein neues Stadium heben
+
+1. Wechseln in den Branch in dem die änderung übernommen werden soll.
+    - `git checkout int`
+    - `git checkout main`
+    - `git checkout dev`
+2. Mergen von Branch A in Branch B
+    - `git rebase dev`
+    - `git rebase int`
+    - `git rebase main`
+3. übertragung durchführen
+    - `git commit`
+
+_Beispiel: Änderungen aus der dev in int übernehmen_
+
+`git checkout int` um in den int-Branch zu wechslen um dann mit `git merge dev` die änderungen aus dem dev-brache zu übernehmen
+
+
+
 Diverse C/C++ Ausprobierereien
+
+## C/C++
+
+Hallo hier wird alles stehen was wichtig und zum schnellen nachlesen ist
+
+gcc Compiler für C Code
+g++ Compiler für CPP Code
+
+
+|Spalte 1|Spalte2
+|---|---|
+|main.cpp|Diverses C++ gedöns
+|objects.cpp|Diverse Opjekte

ax_funktions.hpp

@@ -0,0 +1,51 @@
+//Funktionsdeklaration ax_funktions.hpp
+
+#pragma once
+
+namespace ax{
+    void print_number(int x)
+    {
+        std::cout << "Die Zahl ist: " << x << std::endl;
+        std::cout << "Das doppelte der Zahl ist: " << x*2 << std::endl;
+    }
+
+    void print_char(char x)
+    {
+        std::cout << x;
+    }
+
+
+
+    int sqrt(int x){
+        return x*x;
+    }
+
+    char shift(char x){
+        return x-1;
+    }
+
+    //allgmeine Funktion Deklaration ohne Argumente oder returns für einen unbekannten Datentyp
+    template<typename T> std::string type_name();
+
+    //Spezialisierte Implementation von type_name() für einen entsprechenden Datentyp vgl. mit überladung
+    template<> std::string type_name<int>() {return "Integer";}
+    template<> std::string type_name<char>(){return "Char";}
+    template<> std::string type_name<float>(){return "Float";}
+    template<> std::string type_name<double>(){return "Double";}
+    template<> std::string type_name<bool>(){return "Bool";}
+
+
+
+
+    template<typename T>
+    void ausgebene(T a){
+        std::cout << a << " ist vom Type " << type_name<T>()<< std::endl ;
+    } 
+
+    //CallByRefference
+
+    int fn_CtUp (int &a){
+        a = ++a;
+    return 1;
+    }
+}

main.cpp

@@ -1,8 +1,113 @@
 #include <iostream>
+#include <string>
+#include "ax_funktions.hpp"
+
+#include "SDL2/SDL.h"
 
 int number = 12;
 
+char Buchstabe = 'a';
+
+class Fahrzeug
+{
+private:
+    int kw;
+    float ps;
+    float verbrauch;
+public:
+    std::string Hersteller;
+    Fahrzeug(std::string s_Hersteller, int i_kw);
+    ~Fahrzeug();
+
+    void mechanical_view();
+    float fn_enginechange(int new_kw);
+
+};
+
+Fahrzeug::Fahrzeug(std::string s_Hersteller, int i_kw)
+{
+    kw = i_kw;
+    ps = i_kw * 1.36;
+    Hersteller = s_Hersteller;
+    verbrauch = 6.3;
+}
+
+Fahrzeug::~Fahrzeug()
+{
+}
+
+float Fahrzeug::fn_enginechange(int new_kw){
+    float cost = 0;
+    cost = 100+new_kw*10;
+    this->verbrauch = new_kw/(100*.3);
+    this->kw = new_kw;
+    this->ps = new_kw*1.36;
+
+    return cost;
+}
+
+void Fahrzeug::mechanical_view(){
+    std::cout <<"Das Gerät ist von "<< Hersteller <<  " und hat eine Leistung von "<< kw <<"kw ("<<ps <<" ps)"<<std::endl;
+}
+
+
+float fn_tunung(Fahrzeug &geraet){
+    float cost = 0.0;
+    geraet.Hersteller = "BMW M";
+    cost = 25;
+
+    
+    return cost;
+}
+
+
+
 main()
 {
     std::cout << "Hallo Welt" << std::endl << number << std::endl;
+
+    std::cout << "experimentelle und evtl nicht fehlerfreier Code" << std::endl;
+
+    //Funktionstest
+
+    for (int i = 0; i < 2; i++)
+    {
+        ax::print_number(i); // neue Funktion unsicher und unvollständig
     }
+
+    ax::print_number(ax::sqrt(3));
+
+    for (int i = 0; i < 26; i++)
+    {
+        ax::print_char(Buchstabe+i);
+        std::cout<< " wird zu: " << ax::shift(Buchstabe + i)<< std::endl;
+    }
+
+    double testdouble = 3.1416;
+
+    ax::ausgebene(Buchstabe);
+    ax::ausgebene(42);
+    ax::ausgebene(true);
+    ax::ausgebene(testdouble);
+
+    ax::ausgebene(number);
+    ax::fn_CtUp(number);
+    ax::ausgebene(number);
+
+    Fahrzeug erstes_Auto("BMW", 100);
+    erstes_Auto.mechanical_view();
+
+    std::cout << "Ich wusste nur das es ein " << erstes_Auto.Hersteller << " ist"<<std::endl;
+
+    fn_tunung(erstes_Auto);
+
+    std::cout << "Nun ist es ein " << erstes_Auto.Hersteller << " !"<<std::endl;
+
+    erstes_Auto.fn_enginechange(180);
+
+    erstes_Auto.mechanical_view();
+
+}
+
+
+

readme.adoc

@@ -1,14 +0,0 @@
-# Readme
-
-## C/C++
-
-Hallo hier wird alles stehen was wichtig und zum schnellen nachlesen ist
-
-gcc Compiler für C Code
-g++ Compiler für CPP Code
-
-|===
-|Spalte 1|Spalte2
-
-|main.cpp|Diverses C++ ged
-|===