cppmod2022W20

Während der Schulung im Webex-Chat verteilte Links
zu Beispielen und Aufgaben mit Online-Compilern.

ZIP-Archiv mit C++-Sourcen:

https://drive.google.com/file/d/11t-1QyVxn1IcRK4Dq_X-nqm1j2VeUoF5/view?usp=sharing

Sämtliche Demo-Beispiele aus der Schulung zur lokalen Kompilierung
(= jeweils eine Datei `demo.cpp` in einem eigenen Unterverzeichnis):

Pfad zu Infografiken:

https://tbfe.de/data/uploads/infographics/

Der Inhalt bzw. Zweck der Info-Grafik sollte (einigermaßen) aus dem Dateinamen ersicthlich sein.

Kompilierbarer C++-Source Code (Demos, Übungen, Lösungen) aus den einzelnen Schulungstagen, so wie im Chat verteilt.

(Die Links sind nach dem Kopieren des Chat-Inhalts leider nicht mehr direkt anklickbar. Man muss sie also erst markieren und dann mittels Copy&Paste in die Adressezeile des Browsers übertragen.)

Dienstag

9:06 https://onlinegdb.com/yN8NH8Ou0
Basis zur Publisher/Subscriber-Aufgabe (sie TBDs)

9:31 https://onlinegdb.com/RvDIjtuTm
Erste (einfache) Lösung: (es folgt noch eine weitere mit "automatisierten Tests".

9:37  https://onlinegdb.com/87IseTjz3
"TDD-Stil" Musterlösung

10:11  https://onlinegdb.com/23V9z10It
Lösung mit STL-Algorithmen (`find`, `distance`)

10:26  https://onlinegdb.com/eAsI8Hh1I
Verwendung der Klasse `std::array` (statt native Arrays)

10:39  https://onlinegdb.com/zOWeGxrJ2
Lösung mit `std::for_each` statt range-based for-Schleife und Lambda

11:33  https://onlinegdb.com/fO-M0kanF
Weitere Beispiele mit Funktor und benanntem Lambda:

Wer möchte, kann ab 13:00 schon mal SELBST das Folgende versuchen (prinzipiell nicht sehr schwer, es ist dann auch teil der später besprochenen Variante):

• Die Registy so ändern, dass der erwartete `CallableType` folgendes ist:
  `std::function<void(int, std::ostream&)>`
•  Das heißt dann natürlich, dass ALLE bisherigen Funktionen ein weiteres (erstes) Argument vom Typ int entgegennehmen müssen.

Basierend darauf werde ich anschließend diverse Anpassungen zeigen, mit welchen "nicht ganz passende" Funktionen dennoch mittels `r.attach` als Observer registriert werden können. 

13:03  https://onlinegdb.com/W-U980CNL
Und hier schon mal die (Teil-) Lösung, die nachher noch weiter ausgebaut wird.

14:13  https://onlinegdb.com/9wgSa4tLf
Demo zu lambda vs. `std::bind` (Argumente vertauschen oder mit festen Werten versehen)

14:47  https://godbolt.org/z/rPPM93YKx
C'tor delegation PLUS C'tor Tag-Dispatch Technik

15:23  https://godbolt.org/z/GK6sejnMz
Beispiel für klassenspezifische Typ-Umwandlungen und `explicit`

15:33  https://godbolt.org/z/vzjvEenME
Vorheriges Beispiel nochmal, vorbereitet als Template aber auch noch mit einigen  offenen Punkten, die für eine "gute" und effizient nutzbare Bibliotheksklasse betrachtet werden müssten.

Mittwoch

10:39  https://onlinegdb.com/dZgSjkcpF
Observer Pattern Anfangszustand Mittwoch

11:07  https://onlinegdb.com/5QVgFOKdU
Letztes Observer-Pattern Beispiel (noch nicht mit passendem Test versehen)

11:10  https://onlinegdb.com/Qc8q4ln5r
Und hier nochmal  mit angepasstem Test:

12:21  PM

• Erste Modfikation: kleinen Wert für MAX_SIZE wählen und zeigen, dass bei Erreichen der betreffenden Sunscriber-Zahl r.attach() den Wett `0` zurückliefert. 
• Zweite Modifikation: Anstatt des `std::array` einen `std::vector` verwenden und wenn kein freier Platz da ist, statt `0`zurückzugeben den neuen Subscriber hinten anhängen.
• Geignete Member-Funktionen des `std::vector` sind `push_back` und `emplace_back` (Unterschied wird im Rahmen der Musterlösung erläutert).
• Empfehlung: die Tests in `main` vielleicht auch etwas "aufräumen", also in unterschiedlichen Funktionen zusammenzufassen. Beim weiteren Ausbau verbessert das später die Übersichtlichkeit.

13:13  https://onlinegdb.com/Gmw5Q0vfZ

• Zwischenzustand: `main` umstrukturiert in einzelne Test-Funktionen (aber immer noch nicht komplett aufgeräumt).

13:18  https://onlinegdb.com/tJTcOFce2
Test auf begrenzte Anzahl von 2 sunscribern:

13:41  https://onlinegdb.com/ryoo8yDKb
Erweitert um eine Member-Funktion `detach_all`

13:48  https://onlinegdb.com/s3RB7fRHv
Zusätzlich Delegation von `size` und `empty` an die entsprechenden `std::vector` Member-Funktionen.

14:04  https://onlinegdb.com/M9RbakxUaB

Jetzt mit `std::vector` als private Basisklasse und Typ-Definition `Container` zur besseren Lesbarkeit.

14:10  https://onlinegdb.com/ieSwUMnpe
Lösung ohne Typ-Definition für `Container` und direktem Zugriff auf die "geerbten" Member-Funktionen.

Folgender Aufgabe:

• Ersetzen Sie den `std::vector` in der `Registry` durch eine
  `std::map<CallableID, CallableType>`. 
• Passen Sie die `attach`-Member-Funktion so an, das dieses mittels der Member-Funktion `insert` (oder auch `emplace`)  stets ein neues Element einfügt.
• Als Schlüssel sollen dabei sequentiell aufsteigende CallableID-s verwendet werden, wie bisher mit 1 beginnend.
• Die Registry muss also ein neues Member-Daten-Element enthalten, das den letzten verwendeten Schlüssel speichert und bei jedem `attach` inkrementiert wird.
• Beim `detach` verwenden Sie bitte die Member-Funktion der `map`, die den angegebenen Schlüssel löscht. (Bitte nochmal nachsehen, wahrscheinlich heißt diese `erase` (vielleicht aber auch `remove`...?)
• Beim `detach` wird die laufende Nummer für den nächsten zu vergebenden Schlüssel natürlich NICHT wieder dekrmentiert!
• Soweit bis hierher beschrieben, sollte das alles zu den vorhandenen Tests passen. (Denken Sie aber daran, den Header-File `map` statt `vector` zu inkludieren.)

16:05  https://onlinegdb.com/Rrx3PTIfL
Lösung mit `std::map:

17:03  https://onlinegdb.com/vx3u5tcDs
Lösung mit Zufallszahlen als `CallableID`

Donnerstag

8:53  https://onlinegdb.com/3D26poEri
Test für drei Subscriber mit `is_permutation`da Reihenfolge nicht vorhersehbar:

9:54  https://onlinegdb.com/M7sds_oHE
Kombination von `std::map` und `std::list`

10:16  https://onlinegdb.com/f50Xp8_xh
Komposition miitels privater Basisklasse wieder "zurückgedreht" auf Daten-Member
(plus einige `assert`-s)

10:23  https://onlinegdb.com/nbaq_WQYx
Dto. Hilfs-Datentypen public:

11:29  https://godbolt.org/z/avEPsvPxE
`std::tuple`-Beispiel mit modernem Ersatz von `std::tie` durch `auto` und Variablen in eckigen Klammern (Zeilen 90..100).

• Im letzten Stand des durchlaufenden Beispiels sollen die beiden getrennten Datenstrukturen `subscribers` und `call_order_ ` zusammengefasst werden in nur EINE `std::list`  welche die `CallableID` und den `CallableType` zu einem zu einem `std::tuple` zusammenfasst.

12:01  https://onlinegdb.com/TmhzkwdYZ
"Fast" fertige Lösung.

12:19  https://onlinegdb.com/zDpJO2qrg
Endgültige Lösung:

13:01  https://godbolt.org/z/Y74qcTTG6
Aufgabenstellung für zwischendurch.

13:10  https://godbolt.org/z/WEe8hza66
Zugehörige Lösung.

14:29:29  https://godbolt.org/z/8WhvKveoa
Weitere Lösung mit regulären Ausdrücken.

14:55  https://onlinegdb.com/GjEtNgrZy
"Kochrezept" für Registry mit variabel langen Template-Argumentlisten.
(Anregung "side by side" Vergleich mit vorheriger Variante machen.)

15:17  https://godbolt.org/z/84ofzzWez
Abschließende Version vom Zwischen-Beispiel mit regulären Ausdrücke.

16:26  http://coliru.stacked-crooked.com/a/eb7ee896015649b6
Aufgabe bis morgen (ÜBERLEGEN, mittels "Ausprobieren geht das NICHT!)

Freitag

08:30 zur Aufgabe vom Donnerstag:

• minimal möglicher Zählerstand: 2[*]
• maximal möglicher Zählerstand: 8

[*: nähere Erläuterung hier: https://docs.google.com/spreadsheets/d/1HV_jziIUacbUWqoAXVI3Y5-XmOpZJVnIibLcJHY9DnI/edit?usp=sharing]

9:55 https://godbolt.org/z/Wjqq19Yeq
Die wesentlichen Beispiele aus dem Multi-Threading Teil für Online-Compiler:

14:18  https://godbolt.org/z/vn5rY6a15
Live-Demo zu "Template-Meta-Programmierung"

2:47  https://godbolt.org/z/s66qbbzeY
Mehrdeutige Überladungen eindeutig machen mit `std::enable_if`

Weitere gesicherte Links (scratchpad):

https://technischeberatungfueredv.my.webex.com/technischeberatungfueredv.my/j.php?MTID=mb8a8e92345ed42803a07e8112ab1f175

Gesicherter Zwischenzustand (warum gesichert nicht ganz klar, vielleicht überflüssig?)
https://onlinegdb.com/awaQmVCqJd