<sub class="descriptionSection">01-01-2025 04:12:pm // #Tag // [[Pro 1. SA]]</sub> ____ Grundlagen in C++ umfassen basic Syntax, basic Datentypen, variablen, wiederholungen, etc. ## Basic C++ Syntax Eine Anweisung in C++ ist immer so aufgebaut: - Keyword / Anweisung - Semicolon (;) am Ende einer Zeile Beispiel: ![[Pasted image 20250101161842.png]] Das Beispiel definiert die Variable "coolNum" und weißt ihr den Wert 12 zu. (EOL = End of Line) ## Variablen, Konstanten In C++ werden Daten in Variablen und Konstanten gespeichert. C++ ist eine "strongly-typed" Sprache, das bedeutet, das **jede Variable und Konstante** explizit ein Datentyp übergeben werden muss. ### Datentypen Ein Datentyp definiert welche Werte in einer Variable gespeichert werden können. Beispiele für Datentypen: | Datentyp | Beispiel | Details | | -------- | ----------- | ------------------------------------------------------------------------------------------------- | | int | 1248312 | Ganzzahlen, kann eine relativ lange zahl speichern und ist trotzdem noch speicher sparend | | float | 12.5431 | Floatkomma Zahlen, kann kommazahlen speichern | | char | A | Kann einen einzelnen Buchstaben speichern | | long | 12572398457 | Ganzzahlen, kann seeeehr hohe zahlen speichern ist aber auch nicht so speicher sparend | | double | 1241.212345 | Kann präzisere Floatkomma Zahlen speichern als ein float, da der Datentyp länger im Speicher ist. | Es gibt noch mehr Datentypen, die zähl ich jetzt aber nicht alle hier auf :) #### Compound-Datatypes Manchmal kann man Datentypen einen extra Datentypen übergeben, der dann bestimmt welchen zusätzlichen Datentyp man in ihm Speichern kann. Ein beispiel wäre ein Vektor, der als extra Datentypen den int übergeben bekommt. Der Vektor könnte dann nur integer speichern. | Datentyp | Beispiel | Details | | ------------- | --------- | ------------------------------------- | | `vector<int>` | {1, 2, 3} | Ein Vector der Integer speichern kann | | `stack<int>` | {1, 2, 3} | Ein Stack der Ints speichert | #### Auto Types / Dynamische Types In bestimmten fällen kann man in C++ Datentypen nehmen die sich Dynamisch Verhalten. Ein Beispiel wäre der `auto` type, der automatisch den Datentyp übernimmt, welcher aus der Variable die der auto variable übergeben wird inferred wird. | Datentyp | Beispiel | Details | | -------- | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `auto` | ```cpp<br>int intVar = 2;<br>auto test = intVar;<br>``` | Nimmt den Datentyp der ihm übergeben wird und nutzt diesen dann. | | size_t | `size_t maxInt = 10;` | Da Integer auf verschiedenen Systemen unterschiedlich lang sind (32 bit vs 64 bit z.B) wird size_t genutzt um immer einen ganzzahl typen zu haben der gleich lang ist wie **der größt mögliche Integer**. [Cpp Reference Artikel zu Size_T](https://en.cppreference.com/w/c/types/size_t) | ## Variablen Variablen werden in zwei Stufen erstellt: der Deklarierung und der Initialisierung. In der Variablen Deklarierung wird die Variable erstellt und der Speicherplatz reserviert im RAM. In der Initialisierung wird der Variable ein Wert zugewiesen. Beispiel: ```cpp int coolNum; //Variablen Deklaration, die Variable existiert und hat speicherplatz reserviert coolNum = 12; //Variablen initialisierung, Variable bekommt einen Wert ``` Wenn z.B die Initialiserung vergessen wird kann es dazu kommen das ein wert aus dem Speicher gelesen wird, der noch vom vorherigen Programm genutzt wurde und somit ein zufälliger wert herauskommt. Wenn man somit in dem Beispiel zwischen Deklaration und Initialisierung den Wert liest, kommt etwas zufälliges heraus: ```cpp int coolNum; //Variablen Deklaration, die Variable existiert und hat speicherplatz reserviert std::cout << "Cool Number: " << coolNum << std::endl; //Ergebniss wäre zufällig, z.B würde der Output sein: "Cool Number: 12796892" coolNum = 12; //Variablen initialisierung, Variable bekommt einen Wert std::cout << "Cool Number: " << coolNum << std::endl; //Ergebniss wäre nicht zufällig, hier würde immer: "Cool Number: 12" rauskommen ``` ## Konstanten Konstanten sind eine art von Variablen die man nach der Initialisierung und Deklarierung **nicht mehr** ändern kann. Das ist vor allem sinnvoll für API keys, Mathematische Konstanten wie PI, etc. ```cpp const int coolNum = 12; //Variablen Deklaration und Initialisierung müssen zusammen erfolgen, nach der Deklaration kann der Wert nicht mehr geändert werden!! coolNum = 15; //Würde nicht gehen und schon garnicht compilen const int coolNum2; //Würde schon funktionieren dann ist hier aber ein nicht änderbarrer random speicher bereich drinnen ``` ## Stacks Stacks sind ein Datentyp in C++ der dem FIFO (First in First out) Design entspricht. Man kann unendlich viele Dinge auf einen Stapel legen und immer nur das erste Element sehen. Man kann das erste Element entfernen und dann auf den Wert danach zugreifen. Meist wird sowas genutzt um eine Historie von Befehlen zu haben, etc. ```cpp #include <stack> //Stacks sind nicht in der std lib drinnen, allerdings sind sie im std namespace int main(){ std::stack<int> stackTest; //definiert den stack stackTest.push(12); //legt die nummer 12 auf den Stack std::cout << stackTest.top() << std::endl; //.top() gibt uns die neueste Zahl aus, in diesem Fall 12 stackTest.push(178); //legt die nummer 178 auf den Stack std::cout << stackTest.top() << std::endl; //.top() gibt dieses Mal 178 aus stackTest.pop(); //.pop() entfernt die oberste Zahl vom Stack std::cout << stackTest.top() << std::endl; //.top() gibt uns jetzt 12 aus wieder weil 178 entfernt wurde stackTest.pop(); //.pop() entfernt jetzt die 12 vom Stack std::cout << stackTest.top() << std::endl; //hier wirft das Programm jetzt einen Fehler weil .top() es nicht geben kann bei einem leeren stack return 0; } ``` ## Loops Loops sind eine Art von Kontrollstruktur, die hilft zu kontrollieren wie oft oder lange ein Programm läuft. Es gibt drei Arten von Loops - Kopfgesteuerte Schleife - Fußgesteuerte Schleife - Zählergesteuerte Schleife (Besondere Art von Schleife, da eigentlich alle schleifen irgendwie zähler gesteuert sind) ### Kopfgesteuerte Schleife Als Kopfgesteuerte Schleife versteht man die `while` Schleife. ```cpp int i = 0; while(i < 10){ cout << i << endl; //0, 1, 2, 3, 4, 5, 6, 7, 8, 9 i++ } ``` ### Fußgesteuerte Schleife ```cpp int i = 0; do{ cout << i << endl; //0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 i++; } while(i < 10) ``` ### Zählergesteuerte Schleife ```cpp for(int i = 0; i < 10; i++){ cout << i << endl; //0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } ``` ## Compiler und Interpreter Es gibt zwei ARten von Programmier Sprachen: Compilete Sprachen und Interpreter Sprachen. Der große unterschied ist: Bei Compileten Sprachen wird das ganze Programm beim bauen Compiled und dabei in Maschinencode umgewandelt, beim Interpretierten Sprachen werden die gerade genutzten Teile des Codes in Maschinencode umgewandelt und ist somit langsamer und der nutzer braucht eine Kopie des Codes.