Dieses Tutorial versucht sich daran „Modern C++“ zu vermitteln. C++ basiert ursprünglich auf C und wird daher in der Regel als Weiterentwicklung von C vermittelt, welches zusätzlich objektorientierte Programmierung unterstützt. C++ gilt als schwer zu erlernen und bietet mit C auch ein Erbe an vielen Fallstricken. C++ ist weiterhin auch erstmal eine Erweiterung zu C, allerdings haben sich daraus gerade im professionellen C++-Bereich haben Techniken etabliert, die so in C nicht vorkommen. Die Standard-Template-Library schützt den Entwickler vor viele der in C-Programmierung bekannten Fallen. Mit C++ kann man nicht mehr als in C entwickeln, aber man kann zuverlässigere Software in kürzerer Zeit entwickeln, wenn man sich an die moderne C++ Entwicklung hält. Auch im Vergleich zu anderen Programmiersprachen kann man klassische, C-lastige C++-Entwicklung und moderne C++-Entwicklung unterscheiden. Hier bietet C++ zwar im Vergleich eine sehr geringe mitgelieferte Funktionalität, aber die Sprache selbst ist ihre lange Präsenz im hochprofessionellen Bereich anzuerkennen, deren Unterstützung gerade bei großen Projekten wichtig ist und die sonst keine Programmiersprache in dem Format und in der Performance liefert.

Das Tutorial wird abwechselnd theoretische Belange betrachten und diese anschließend praktische Umsetzen betrachten. Ich werde versuchen die Blöcke klein zu halten, um schnell und häufig wieder zur Praxis zu kommen, die Theorie ist zum Verständnis aber nunmal auch wichtig und gehört dazu.

Dieses Tutorial baut nicht auf dem vorhandenen C-Tutorial auf, weil wir C++ hier nicht als Erweiterung begreifen, sondern andere Techniken verfolgen und teilweise andere Begriffe verwenden. Wir fangen bei Null an, werden aber immer wieder Referenzen in C-Tutorial setzen. Ich empfehle durchaus, sich auch mit dem C-Tutorial im Anschluss zu beschäftigen, um C-lastige Quelltexte besser zu verstehen und das grundlegende Verständnis für den Computer zu vertiefen.

—- CUT —-

Ziel: Die benötigte Software installieren Theorie: Was ist Programmieren? Was ist ein Compiler, Tool-Chain, Bibliothek, Executable Praxis: gcc, mingw Praxis: kompatible IDE installieren

Ziel: Etwas kompilieren zu können Theorie: Aufbau eines Programms, Kommentare, Funktionen (oberflächlich), Unterschied Objektinstanz, Datentyp, Speicher, Adresse, Wert, Variable, Konstante, Namensräume (oberflächlich), main als Startpunkt Praxis: Hello World Theorie: cout als Ausgabe und der operator «.

Ziel: Zwei Werte Berechnen, aber maximal 100 als Ergebnis. Theorie: Was ist ein Identifier, was ist eine Variable, was ist eine Funktion, Datentyp Integer, erster Blick auf Scopes/Blöcke Praxis: Funktion add(1, 2) schreiben Theorie: Call by Value, Call by Reference Praxis: bool addiere( int, int, int & ) Theorie: Expressions: Wert operator Wert, Mathematische Operatorn: +, -, *, / und % Praxis: Funktion addiere direkt bei cout aufrufen und mit Variablen füllen statt mit Theorie: Entscheidungen treffen: if, Logische Operatoren: ==, >, <, >=, ⇐, !=, Datentyp bool Praxis: Ergebnisse über 100 abfangen

Ziel: Texte ein und ausgeben, Strings concatenieren, Theorie: Was ist ein std::String, wie muss man sich das im Speicher vorstellen? Ein Buchstabe/byte ist ein char Praxis: „Hello“ + „World“ Aufgabe: Eine Funktion string concat( string, string ) schreiben und das Ergebnis ausgeben Theorie: StringBuffer Praxis: Einen String zusammenstellen (buf « a « „ plus “ « b « addiere(a,b) « endl;) Theorie: Die std::to_string() Funktion. Praxis: concat( to_string(1), to_string(2) ); Theorie: Zugriff per [] - Zählweise 0 bis length-1 Praxis: String verändern Praxis: erase, pushback,

Ziel: Einen Datenpunkt beschreiben, der Punkte repräsentiert Theorie: Unterschied Klasse/Datentyp, Instanz/Objekt, was ist Konstruktion und (Default-)Destruktion, Attribute, Aufgabe Point2 Praxis: class Point2 schreiben und konstruieren mit x und y (Initialisierungsliste: Point2{1,2};) Theorie: Methoden Praxis: move( x, y ) schreiben Theorie: operator + Praxis: operator + (Point) Aufgabe: operator - (Point) und operator * (int) schreiben. Theorie: operator ==, Logische Operator &&, ||, ! Praxis: operator == Aufgabe: operator != Theorie: sizeof-Operator, size_t Datentyp Praxis: sizeof Point2 ausgeben und sizeof( int ) ausgeben

Ziel: Dateien zu lesen und zu schreiben Theorie: Die Idee hinter Streams, cout als Stream auf die Konsole, cin als Stream von der Tastatur Praxis: istream::getline, operator » und std::getline Theorie: Konvertierungen von string nach int, int nach string Praxis: istream » i Theorie: Die Standard-Eingabe, Eingaben pipen Praxis: Beispiel echo „Hello“ | myprog, myprog | less, ein bisschen mit grep spielen Theorie: ifstream Praxis: Eingabe aus einer Datei ziehen Praxis: operator » (ostream, Point2) überladen Theorie: ofstream Aufgabe: operator « (ostream, Point2) überladen.

Ziel: Einfache Container kennen Theorie: String als container, foreach( char c : hworld ) Praxis: Einzelne Buchstaben des Strings ausgeben Theorie: std::array, initializer liste Praxis: Array mit 10 Ints Theorie: std::vector, push_back, operator [] Aufgabe: String in einen vector<char> kopieren Theorie: Klasse Polygon Praxis: Klasse Polygon als std::vector< Point2 > Theorie: Interface: length(), capacity(), empty Aufgabe: to_lower, de_umlaut (UTF?) Theorie: listen Praxis: Vergleich Elemente vorne einfügen (1 sekunde lang, wie oft?) Theorie: stack und queue, deque, forward_list

Theorie: begin(), rbegin(), T::iterator, end() ist kein Element, auto <algorithm> ein wenig abarbeiten Praxis: std::copy, std::count, find, rfind, transform, swap, for_each, replace

<algorithm> ein wenig abarbeiten Praxis: copy_if,std::count_if find_if,

Theorie: Sets Praxis: Buchstaben zählen Theorie: std::pair

Theorie: Maps Praxis: Theorie: unordered_set, unordered_map; multiset, multimap

Konstanten const ref const methods RückgabeWERTE sollten nicht const sein

Theorie: Wozu dienen Headerfiles und Quellen Praxis: point2.h, point2.cpp, main.cpp Theorie: Eigene Namensräume eröffnen prg::point2, Include-Verzeichnisse angeben Praxis: prg-Verzeichnis anlegen

Theorie: new, delete, Pointer Praxis: new Point2 Theorie: new std::array< Point2,10 > Theorie: new Point2[10] Praxis: for( int i… ) ptr[sizeof(ptr)] → Overflow Theorie: shared_ptr, weak_ptr, unique_ptr

Theorie: Fließkommazahlen Praxis: point2 auf double umschreiben Ungenauigkeiten, Numerik, heitaitai, alles weiter nach hitnen :)

Sequenzpunkte (i++ + i++ ⇒undef. Verhalten), MoveSementik (Rule of x), R-Value referenzen (&&); Initialisierungslisten; numeric_limits, Linksbindend, außer rechtsbindend; auto const, auto &; Vorwärts-Referenzen; enum class/struct; Unterschied class struct Implizite Konvertierungen; Prototypen/Funktionsdeklarationen auto f() { return true; } Default argumente implizite Konvertierung von Parametern Rekursion: Fibonacci, Bäume Type_info tuple, std::tie, std::ignore variant

Detlef13.5

Globale Variablen, Ellipsis,

——–CUT———–

• Neue Operatoren: Speicher anfordern und freigeben mit new und delete
• Initialisieren von Variablen
• Neue Datentypen
• Default Parameter
• Neue Casts
  • Statische Casts

• Was ist klassenbasiertes Programmieren?
• Wie definiert man eine Klasse
• Was ist ein Member? - Variablen, Methoden und statische Funktionen
• Der this-Pointer - Der Zeiger auf sich selbst
• Statische Member
• Konstruktoren
• Casten durch Umformen
• Die Initialisierungsliste
• Kapselung: Member verstecken (Information Hiding)
• Destruktoren
• Was ist eine inline Methode?

• Was sind Referenzen?
• Anwendungsfälle und Beispiele
  • Referenzen als Funktionsparameter
  • Referenzen als Membervariablen
  • dynamisch Referenzen erzeugen

• Die Spielregeln zum Ableiten
• Basiskonstruktoren rufen
• Überschreiben
• Mehrfachableitungen
  • Gleichnaminge Member in zwei Basisklassen
  • Das Diamant-Problem
  • virtuelle Ableitungen

• Funktionen und Methoden überladen
• Überladene Funktionen in den Namensraum zurückholen
• Operatorüberladung

• Einführung
• Einen Namensraum anlegen eines Namensraum
• Zugriff auf Elemente eines Namensraums
• Namensräume einbinden oder einzelne Elemente aus einem Namensraum einbinden

• Was ist Const-Correctness?
• Const-Argumente
• Const-Methoden
• Veränderbar, trotz Const: mutable
• Brecheisen für alte Quelltexte: Const-Casts

• Was ist objektorientierte Programmierung?
• Objektorientierung über Funktionspointer
• Objekttyp-orientierte Programmierung
  • Probleme bei CallByValue-Aufrufen (Slicing)
• virtuelle Methoden Objekttyporientierte Programmierung mit C++
• virtuelle Destruktoren Objekttyporientierter Abbau von Objekten
• Interfaces (Pure virtual methods)

• Run-Time-Type-Information (RTTI)
• Dynamische Casts

• Funktor
• Prä- und Post-Funktionen

• Was sind Templates?
• Template-Funktionen
• Template-Klassen
• Template-Templates
• Meta-Programmierung

• Reinterpretierende Casts
• Placement New