===== Variablen =====

^Typ ^Wertebereich ^Byte ^Beschreibung ^
|unsigned short int|0-65535|2|Ganzzahlen ohne Vorzeichen bis 65535|
|short int|-32768 bis 32768|2|Positive und Negative Ganzzahlen|
|unsigned long int|0-4294967295|4|Positive Ganzzahlen bis 4294967295|
|long int|-2147483648 bis 2147483647|4|Positive und negative Ganzzahlen|
|char|Zeichen|1|Ein Zeichen|
|float|1,2e-38 bis 3,4e38|4|Bruchzahlen/Kommazahlen im negativen und positiven Bereich|
|double|2,2e-308 bis 1,8e308|8|Bruchzahlen/Kommazahlen im negativen und positiven Bereich|
|bool|True/False| ? |Wahrheitswert - True -> Wahr, False -> Unwahr |
\\ \\
unsigned -> ohne Vorzeicehn, es lassen sich nur positive Werte abbilden

==== Konstaten ====

  * Variablen denen nur bei der Deklaration ein Wert zugewiesen werden kann
  * Im Programmverlauf können sie nicht mehr geändert werden

const //Typ Bezeichner// = //Wert//


===== Operatoren =====
==== Arithmetische Operatoren ====

^Name ^Beschreibung ^
|--|Decrement|
|++|Increment|
|+=|Zuweisung und Addition \\ \\ Wert vor dem = wird mit dem Wert hinter = addiert und in der Variable vor = gespeichert. \\ \\ a+=2 -> a=a+2;|
|-=|ZUweisung und Substraktion \\ \\ Siehe +=|
|*=|Zuweisung und Multiplikation \\ \\ Siehe +=|
|/=|Zuweisung und Division \\ \\ Siehe +=|
|%=|Modolu und Zuweisung \\ \\ Rest einer Division|
|==|Vergleichsoperator|
==== Logische Operatoren ====

^Name ^Beschreibung ^
|&& |Logisches Und|
| <code>||</code> | Logisches Oder|
|!|Logisches Negieren - Ausdruck ist wahr, wenn die Bedingung unwahr ist \\ \\ **Beispiele:** \\if (!(a==5)) \\ if (a!=5)|
==== Tertiär-Operator ====

  * Ersetzt if-Anweisung wenn nur entweder ein Wert oder ein anderer zurückgegeben werden soll (Abhängig von der Bedingung)
  * Liefert je nach dem ob der Ausdruck wahr ist Wert1 oder Wert2 zurück
\\
Syntax: (Bedingung)?Wert wenn True:Wert wenn false;

==== Sonstige Operatoren ====

^Function/Kommando ^Erklärung ^
|static_cast<//Typ//>(//Variable//) | Temporäre Typumwandlung \\ \\ Bei einigen Operationen (zum Beispiel Division müssen Ganzzahlen in Float umgewandelt werden um Brüche zu erhalten) müssen Variablen eines Typs temporär in Variablen eines anderen Typs umgewandelt werden. \\ \\ \\ Syntax: static_typecast<//Typ//>(//Variable//) \\ \\ Typ: Typ in den umgewandelt werden soll (int, fload, char usw.). \\ \\ **Hinweis:** Offensichtlich kann man nicht mehrere Variablen mit einmal umwandeln. Aktionen wie static_typecast <float> (a / b) funktionieren nicht. |
|typedef //Typ// //NeuerName// | Definiert einen anderen Namen für einen Variablentyp. \\ \\ **Hinweis:** typedef definiert keine neuen Variablentypen, es ermöglicht nur einen anderen Namen für einen vorhandenen Typ zu definieren (zum Beispiel einen kürzeren). \\ \\ Syntax: static_typecast //Typname// //Neue Bezeichnung// \\ Beispiel: typedef unsigned short int usint \\ \\ Typname: Name des vorhandenen Typs \\ Neue Bezeichnung: Benutzerdefinierte Bezeichnung für den Typen | 
===== Methoden/Befehle =====

===== Konstrukte =====

==== Klassen/Methoden ====

  * Definieren neue Typen
      * ähnlich Variablentypen oder struct - nur das Klassen auch Methoden umfassen können
  * können Methoden und andere Typen umfassen


Deklaration:

<code>
class //Klassenname//
{
      Private:
                //Variablen-Deklaration1//;
                //Methoden-Deklaration1//;
      Public:
               //Variablen-Deklaration2//;
               //Methoden-Deklaration2//;
};

//Rückgabetyp// //Klassenname//:://Methodenname(//Parameterliste//)
{
         Code;
}
</code>

<code>
class Testklasse
{
     Private:
               int rechnen(int, int);
               int ergebnis;
     Public:
               void ausgabe ()
};

int Testklasse::rechnen(int a, int b)
{
       int p_return;
       p_return=a+b;
       return(p_return);
}
</code>

  * Klassenname: Name der Klasse
  * Private/Public: Definiert ob die dahinter/darunter definierten Methoden und Variablen als von außerhalb der Klasse zugänglich (public) oder für nur von der Klasse zugänglich (private). **Hinweis:** Public/Private kann auch direkt vor einer Variablen-Deklaration angegeben werden - muss aber **immer** mit : enden, also Private: oder Public:
      * Nur auf Methoden und Attribute/Variablen die public sind kann von außerhalb des Objektes zugegriffen werden - private Methoden und Attribute können von außerhalb des Objektes nicht aufgerufen werden
      * **Ausnahme:** Objekte des gleichen Typs können auf private Elemente der jeweils anderen des gleichen Typs zugreifen -> 2 Objekte der Klasse Car, können gegenseitig auf ihre privaten Elemente zugreifen
  * Variablen-Deklaration: Deklaration von Variablen - genauso wie außerhalb einer Klasse auch -> man kann vor jeder einzelnen Variable private/public angeben
  * Methoden-Deklaration - (nicht Definition -> es steht also nicht der Code der Methode an dieser Stelle) - Deklaration wie außerhalb einer Klasse auch -> Rückgabetyp Methodenname (Übergabety1, Übergabetyp2)
      * bei der Deklaration werden für die Übergabevariablen keine Namen angegeben, nur Typen
      * vor jeder Methode kann private bzw. public angegeben werden 
  * **Definition Methode**: 
      * Definition Methode erfolgt wie bei normalen Methoden außerhalb von Klassen
      * vor den Methodenname wird durch : getrennt der Klassenname gesetzt
      * Methoden von Klassen müsen innerhalb der Klasse deklariert worden sein
\\ 
**Achtung:** KLassendefinitionen müssen nach der letzten Klammer } mit ; abgeschlossen werden (Klassenmethoden nicht).


=== Konstruktoren ===

  * Methode die automatisch beim erschaffen eines Objektes aufgerufen wird
  * hat jede Klasse automatisch
  * verfügt standardmäßig über keinen Code
  * kann durch Programmierer mit Code, der beim Erstellen eines Objektes aus der Klasse ausgeführt werden soll, gefüllt werden
  * Methode hat den gleichen Namen wie die Klasse

\\ \\ 
Syntax:
<code>
class Klassenname
{
      public: Klassenname();
      KLassendefinitioon;
};

Klassenname::Klassenname ()
{
    Code;
}
</code>

=== Destruktoren ===

  * Methode wird automatisch aufgerufen wenn ein Objekt aufgelöst wird
  * jede Klasse hat automatisch diese Methode -> ist leer
      * Programmierer kann Code definieren der beim auflösen eines Objektes ausgeführt werden soll
  * hat den gleichen Namen wie die Klasse, mit vorangestellter ~


Syntax:

<code>
class Klassenname
{
          public: ~KLassenname
}

Klassenname::~KLassenname()
{
         Code;
}
</code>


=== Konstante Methoden ===

  * nicht zu verwechseln mit static
  * konstante Methoden können keine Elementvariablen ändern und auch keine Parameter übernehmen
  * soll Programmierern helfen Methoden sauber zu deklarieren die keine Variablen ändern sollen
      * zum Beispiel Abfragemethoden, die nur Werte an den Clienten (Aufrufer) zurückgeben sollen -> durch das const wird sicher gestellt, dass keine Implementierungsfehler unterlaufen, weil der Compiler dann weiß was der Programmier bezwecken will
\\

Syntax:
<code>
class Klasse
{
        public:
                 Rückgabetyp Methode() const;
}

Rückgabetyp Klasse::Methode() const
{
     Code;
}
</code>



==== while-Schleife ====

  * Wird durchlaufen solange die Bedingung im Schleifenkopf wahr (gegeben) ist
  * Ist die Bedingung bereits beim ersten Durchlauf nicht gegeben, wir der Code innerhalb der Schleife nicht durchlaufen

Syntax:
<code>
while (Bedingung)
{
       Code;
}
</code>

<code>
while (i<8)
{
        cout << "Der Wert des Zählers ist: " << i;
}
</code>


Eine Sonderbedingung ist true, sie führt zu einer Endlosschleife, die mit break abgebrochen werden muss.

===== Begriffe =====

^Begriff ^Erklärung ^
|Präprozessor|Läuft vor dem Compiler - bereitet den Quellcode für den Compiler vor/bindet Quellcode-Bibliotheken ein \\ \\ Es kann Quellcode (das schließt Quellcode-Bibliotheken ein) aus anderen Dateien eingebunden werden oder Code-Teile von der Compilierung ausgeschlossen werden \\ \\ \\ Code für den Präprozessor wird mit vorangestellter # gekennzeichnet. \\ \\ Zum Beispiel #include <iostream>|
|Compiler|Übersetzt den Quellcode in Maschinencode \\ \\ Es enstteht eine Objekt-Datei (obj)|
|Linker|Läuft nach dem Compiler - fügt statische Bibliotheken ein|
|Dynamischer Linker|Lädt zur Laufzeit dynamisch gelinkte Bibliotheken die das Programm benutzt|
|Bibliothek|Eine Datei die Funktionen/Methoden/Klassen zur Verfügung stellt auf die der Programmierer zugreifen kann \\ \\ Sammlung von zusammengehörigen (thematisch) Funktionen/Methoden und Klassen die der Programmierer in seinem Programm nutzen kann ohne sie selbst zu definieren. \\ \\ Es wird nur auf irgend eine Weise definiert welche Bibliotheken genutzt werden sollen und im Code wird die Methode/Klasse/Funktion einfach benutzt ohne die irgend wo zu definieren.\\ Präprozessor bzw. Linker sorgen dann dafür das die entsprechenden Funktionen in den Code wandern oder beim Aufruf in den Speicher geladen werden. \\ \\ \\ Es gibt Quellcode-Bibliotheken, Statische Bibliotheken und Dynamische Bibliotheken -> Erklärung siehe unter [[cplusplus#Bibliotheken|cplusplus#Bibliotheken]]|
|L-Wert / R-Wert|Linker Wert, Rechter Wert - bezeichnet die Werte vor dem = und hinter dem = bei einer Operation|
|Klienten|Benutzer von Klassen|
|Elementvariablen / Datenelemente / Attributvariablen|Variablen innerhalb einer Klasse|
|Methoden / Elementfunktionen|Funktionen die zu einer Klasse gehören|
|Klienten|Andere Objekte die au ein Objekt zugreifen -> sind Klienten des Objektes|



==== Bibliotheken ====

* stellen dem Programmierer fertige Funktionen/Klassen/Methoden zur Verfügung, die er nicht selbst erstellen muss
* 3 Arten von Bibliotheken

^Typ ^Beschreibung ^Dateiendung ^
|Quellcode-Bibliothek|Die Funktion/Klasse/Methode liegt als Code vor. \\ \\ * Im Code durch #include Bibliotehksname eingebunden \\ * Wird durch den Präprozessor als Code eingebunden und mitcompiliert|.h?|
|Statische Bibliothek|Die Funktion/Klasse/Methode liegt als kompilierte Version vor. \\ \\ * Wir durch Linker nach dem Compilieren als Maschinencode in die ausführbare Datei eingebunden|.a -> Unter Unix-Systemen|
|Dynamische Bibliothek|Die Funktion/Klasse/Methode liegt als kompilierte Version vor - wird zur Laufzeit ins Programm eingebunden \\ \\ * Bibliothek und damit die Definition der Klasse/Methode/Funktion ist nicht im Maschinencode des Programms, sondern in externer Binärdatei \\ * Einbinden übernimmt der dynamische Linker/Binder während das Programm ausgeführt wird|* dll (Dynamic Link Library)-> Windows \\ * so (Shared Object) -> Unixoden Systemen|
===== Präprozessor =====

^Direktive ^Bedeutung ^
|#include <//file-name//>|Bindet eine Bibliothek ein. \\ \\ Wenn die Dtaei in <> steht sollten global (alle Verzeichnisse die der Präprozessor kennt) alle Verzeichnisse durchsucht werden|
|#define|Definiert eine Konstanze - sollte nach Möglichkeit nicht benutzt werden \\ \\ Syntax: #define // Bezeichner // // Wert // \\ \\ Der Präprozessor ersetzt alle vorkommen des Bezeichners im Code durch den angegebenen Wert vor dem compilieren.\\ \\ ** Hinweis: ** Sollte nicht genutzt werden, da der Compiler die Typenzuweisungen nicht prüfen kann (sind ja keine Typen angeben). Statt dessen sollte const (sie Variablen genutzt werden)|


===== Namenskonvention =====

Namenskonvention ist nicht vorgeschrieben und jeder kann seine eigene haben -> aber man sollte eine haben, da man sonst nicht mehr durchsieht was ein Objekt ist, was eine Variable welchen Typs ist und in  welchen Rahmen eine Variable gültig ist. \\ \\
^Bezeichnung ^Konvention ^
|Klasse|cname|
|Globale Variable|TypBezeichner \\ \\ **Typ**=Erster Buchstabe des Typs der Variable (zum Beispiel bei int i) \\**Bezeichner**=Sprechender Name der Variablen|
|Elementvariable / Attribut|itsTypBezeichner \\ \\ **its**=Zeigt an das es sich um ein Attribut/Elementvariable handelt -> its (seine Variable -> die des Elements) \\ **Type**=Erster Buchstabe des Typs der Variable (zum Beispiel bei int i) \\ **Bezeichner**=Sprechender Name für die Variable|

===== Hinweise/Troubleshooting =====

^Problem ^Beschreibung ^
|gcc wirft Fehler "undefined Reference to xyz"|gcc ist der C-Compiler der GNU Compiler Collection, g++ ist der C++-Compiler|
|g++ xyz was not declared in this scope|Namespace nicht angegeben \\ \\ Meist fehlt der Standard-Namespace - unterhalb der #include-Anweisungen muss "using namespace std;" angeben werden|
|return-value does not allow definition|Möglicherweise KLassendefinition nicht mit ; abgeschlossen|


===== Internas =====

==== Funktionsaufruf ====

Folgendes passiert nacheinander:

  * Auf dem Stack wird die Speicherposition des ersten Befehls nach der Funktion abgelegt (Rücksprungadresse)
  * Auf dem Stack wird Speicher für den Rückgabewert freigehalten
  * Der Befehlszeiger wird inkrementiert und verweist auf den Beginn der Funktion
  * Die höchste Position des Stacks wird gespeichert (alle was danach gespeichert sind lokale Variablen innerhalb der Funktion)
  * Die lokalen Variablen innerhalb der Funktion werden auf dem Stack abgelegt
  * die Funktion wird ausgeführt
\\ \\
Ist die Funktion durchgelaufen passiert folgendes:

  * lokale Variablen werden vom Stack gelöscht
  * Rückgabewert wird in Zielvariable gespeichert und vom Stack gelöscht
  * Codezeiger wird auf Rücksprungadresse gesetzt 
  * Rücksprungadresse wird vom Stack gelöscht
\\ \\
Alle Daten der Funktion sind vom Stack entfernt.\\ Der Stack wird immer der Reihenfolge nach belegt und wieder gelöscht.