Typen

Die Sprachen C und C++ zwingen den Programmierer, jeglichen Werten einen eindeutigen Datentyp zuzuordnen, wodurch den darunterliegenden Bits eine strukturelle Interpretation gegeben wird. Dies wird als Typisierung bezeichnet.

Basistypen

`void`	Nichts, unbekannt, ungültig, zu ignorieren, leer
`bool`	Boolscher Wahrheitswert
`char`	Ganzzahl-Wert mit 1 Byte
`short`	Ganzzahl-Wert mit 2 Bytes
`int`	Ganzzahl-Wert mit 4 Bytes
`long long`	Ganzzahl-Wert mit 8 Bytes
`float`	Fliesskomma-Wert mit einfacher Genauigkeit
`double`	Fliesskomma-Wert mit doppelter Genauigkeit
`long double`	Fliesskomma-Wert mit vierfacher Genauigkeit

Weiteres über Basistypen

`Arithmetische Umwandlung`	Wert-Erhaltende Umwandlung arithmetischer Typen
`signed`	Vorzeichenbehafteter Typ
`unsigned`	Vorzeichenloser Typ
`true`	Wahrheitswert für Wahr
`false`	Wahrheitswert für Falsch
`long`	Veraltete Bezeichnung eines 4-Byte-Wertes
`wchar_t`	Wide-Character
`type_info`	Typ für Rückgabewert des typeid-Operators
`bad_cast`	Typ für misslungenes dynamic-casting
`bad_typeid`	Typ für misslungenen typeid-Aufruf

Erweiterte Typen

Erweiterte Typen erlauben es, Basistypen miteinander zu kombinieren und somit beliebig komplexe Typen zu deklarieren. Durch diese Erweiterungen können sämtliche Typen addressiert, strukturiert, zu Funktionen verpackt, mit Eigenschaften belegt und in generischer Programmierung verwendet werden.

Adressierende Typen

`*`	Pointer
`[]`	Array
`&`	Referenz
`void*`	Pointer auf unbestimmten Typ
`Null-Pointer`	Pointer mit dem Wert Null
`(*)()`	Funktionspointer

Strukturierende Typen

`struct`	Zusammengehörige Deklaration
`class`	Klassendeklaration
`namespace`	Gruppierung von Symbolen
`using`	Einbinden einer Symbolgruppe
`enum`	Aufzählungs-Typ
`union`	Gemeinsame Typdeklaration
`Bitfeld :`	Ganzzahl mit bestimmter Bitanzahl
`Attribute`	Compiler-Anweisungen für Typen
`POD, Aggregate`	Plain Old Data und Aggregat-Zuweisung

Funktionen

`Funktions-Deklaration`	Deklaration einer Funktion
`Funktions-Definition`	Definition einer Funktion
`Argumente, Parameter`	Übergabe von Werten und Variablen
`return-value`	Rückgabewert
`Funktions-Überladung`	Gleicher Name aber unterschiedlicher Funktionstyp
`Parameter ...`	Variadische Funktionen
`main`	die main-Funktion
`const`	Keyword für eine Funktion im const-safe-Bereich
`throw`	Keyword für eingeschränktes Exception-Handling
`const-safe`	Sicherer Umgang mit Argumenten
`inline`	Funktion soll direkt in den Code integriert werden

Speicherklassen

`auto`	Automatische Allokation und Deallokation auf dem Stack
`static`	Einmalige Definition
`register`	Benutzung eines Prozessorregisters
`extern`	Allokation und Deallokation an anderer Stelle
`mutable`	Feld ausserhalb von const-safe Bereich eines Objektes
`typedef`	Benennung eines Typs mit einem Symbol

Qualifikatoren

`const`	Werte bleiben unverändert
`volatile`	Werte müssen stets neu ausgewertet werden
`restrict`	Pointer zeigen nicht an überlappende Speicherbereiche

Generische Programmierung

`Templates`	Generische Compilierung
`template`	Keyword für die Deklaration generischer Typen
`class`	Keyword für die Kennzeichnung einer beliebigen Klasse
`typename`	Keyword für die Kennzeichnung eines beliebigen Typs
`export`	Template-Definitionen in einer anderen Datei

Objektorientierte Programmierung

Bei der Objektorientierten Programmierung (OOP) unter C++ wurde das Typsystem um Klassen erweitert. Eine Klasse beschreibt ähnlich wie ein struct mehrere zusammengehörige Felder, doch zusätzlich deklarieren klassen zu diesen Werten dazugehörige Methoden. Durch die Instanziierung mittels eines Klassen-Typs entsteht ein sogenanntes Objekt.

Klassen und Objekte

`OOP Terminologie`	Begriffe in der objektorientierten Programmierung
`class`	Definition einer Klasse
`this`	Pointer auf das eigene Objekt
`Polymorphismus`	Ansprechen des dynamischen Typs zur Laufzeit
`Multiple Inheritance`	Mehrfach-Vererbung

Konstruktoren und Destruktor

`Konstruktor`	Aufsetzen eines Objektes
`Destruktor`	Beseitigen eines Objekts
`Standard-Konstruktor`	Konstruktor ohne Parameter
`Konvertierer`	Konstruktor für implizite Umwandlungen
`Copy-Konstruktor`	Konstruktor für Referenzen der eigenen Klasse

Typerweiterungen unter OOP

`private`	Bereichseinleitung von privaten Klassendeklarationen
`protected`	Bereichseinleitung von geschützten Klassendeklarationen
`public`	Bereichseinleitung von öffentlichen Klassendeklarationen
`virtual`	Methode der erbenden Klasse ist vorzuziehen
`explicit`	Initialisierung muss als Konstruktor geschrieben werden.
`friend`	Externer Bereich darf auf private Daten zugreifen