cppfor2022W18

Literaturhinweise zu Design-Patterns

https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms
- C++ spezifisch ausgrichtet
https://en.wikipedia.org/wiki/Design_Patterns
- immer noch sehr gut, da "das Original"
- aber nicht immer der "beste Weg" in Bezug auf C++ (es erschien zu einer Zeit, in der C++ Templates noch kein "Standard" in den Compilern waren)

C++ FOR 2022 Kalenderwoche

Montagvormittag
- Übung: NUR Code Review von `clock_00`
  https://onlinegdb.com/AmpNYyvGJ
- Übung: TODO aus `clock_00`
Montagnachmittag
- Lösung: `clock_01` gemäß TODO aus `clock_00`(plus `SHOW` - Makro):
  https://onlinegdb.com/VrfIze0s2
- Alternativ (C++98 kompatibel)
  https://onlinegdb.com/Px6QSAvdG
- Übung: TODO aus `clock_01` (Start mit Link zur Lösung oben)
- Lösung: `clock_02` gemäß TODO aus `clock_01`
  https://onlinegdb.com/3fePciRGb
- Alternativ (C++98 kompatibel)
  https://onlinegdb.com/diuSCD-3O
- Übung: TODO aus `clock_02` (Start mit Link zur Lösung oben)
Dienstagmorgen
- Lösung: `clock_03` gemäß TODO aus `clock_02`
  https://onlinegdb.com/-FVQL0etI
- Übung: TODO aus `clock_03` (Start mit Link zur Lösung oben)
- Lösung: `clock_04` gemäß TODO aus `clock_03``
  https://onlinegdb.com/mF1ixkDlb

Links zu kompilierbaren Beispielen:

Live-Demo mit Compiler-Explorer
- https://godbolt.org/z/WjYqf14fs (Copy vs. Move)
- using directive in classes
Infrografiken:
Beispiele aus Kapitel Exceptions
- https://godbolt.org/z/A6bg9U (copy-paste EX-15...18)
- https://godbolt.org/z/S4op5a (copy-paste EX-21...24)
- https://godbolt.org/z/ve-bBX (copy-paste EX-25)
- https://godbolt.org/z/m7K92A (copy-paste EX-26)
- https://godbolt.org/z/iYJ4yJ (copy-paste EX-27)
- https://godbolt.org/z/WquFzw (copy-paste EX-30...33)
- https://godbolt.org/z/5rz1jdWhr (Variante mit `std::out_of_range`)
- https://godbolt.org/z/XHtBLn (copy-paste EX-42...44)
- https://godbolt.org/z/mdVmeY (copy-paste EX-42..43+45)
- https://godbolt.org/z/gejU3B (copy-paste EX-42..43+46

Dienstagnachmittag
- Lösungsdemo: Exercise 1 aus Kapitel 11
  https://onlinegdb.com/XDqJy5uZP6
- Übung: Exercise 2 (Exception Handling) aus Kapitel 11
- https://onlinegdb.com/w87MVvBnwM
- Lösung Exercise 2
  https://onlinegdb.com/gYnCaGDq0
- Übung Exercise 3 (Observer Array Template Class) aus Kapitel 11
  https://onlinegdb.com/Kmi9cm74Y

EINSCHUB: Die verschiedenen Nutzungsformen von C++-Templates
UND AUCH: Operator-Overloading / Typ-Umwandlungen (Best Practices)

Parametrisierung von "Typen" und (Compilezeit-) "Konstanten"
- auch bekannt als "generic programming"
- an Beispielen relativ leicht zu erklären
Meta-Programmierung
- Templates sind eine vollständige "Funktionale Programmiersprache"
- dafür gibt es einige nützliche "kochrezeptartige" Formen der Nutzung
  - (Stichwort: "type traits")
- ein tieferes Verständnis dafür zu schaffen, wie diese Dinge implementiert sind, erfordert aber deutlich mehr Zeit als in diesem Kurs zur Verfügung steht
  - (und ist oft unnötig: "shift complexity from the many to the few")

Mittwochvormittag
- Lösung Excercise 3
  https://onlinegdb.com/kR1p97b1T (Part 1)
  https://onlinegdb.com/kLFvzGtBF (Part 2)
- Übung Exercise 4 (Observer STL-Container) aus Kapitel 11
  https://onlinegdb.com/NxONpJfpX

Mittwochnachmittag
- Lösung Exercise 4
  https://onlinegdb.com/Jh3rl-mFn

Einschub als Praxis-Bezug zum Kapitel 5:

Direkte Verwendung von Lambdas als Argument für STL-Algorithmen:
https://godbolt.org/z/Yaz6Trvfs
https://godbolt.org/z/c7o7v5xYb
"Proof of Concept der Umsetzung des "Publisher/Subscriber"-Patterns mit einem C-Array dessen Elemente den Typ `std::function<void (int)>` haben:
https://godbolt.org/z/T8rcveq3x
Nochmal, aber basierend auf einer `std::map` und gekapselt in einer Klasse (`Registry`):
https://godbolt.org/z/137sf3jec
Weiterer Ausbau, teilweise auch nur etwas schöner formatiert:
https://godbolt.org/z/eYGe49TYK
https://godbolt.org/z/9rj3Yr1E9
Inklusive einiger Beispiele zum `std::bind` und dem Zusamemhang mit Lambdas
https://godbolt.org/z/nsr6Eh3r8
Jetzt angewendet als Alternative zur Lösung Exercise 4:[*]
- https://onlinegdb.com/iQMLfhAQ9
  die Klasse `ObserverRegistry` in `observer_registry.h` ersetzt hier den ehemaligen `ObserverContainer` in `observer_container.h` und
  die TDD-style Tests werden bedingt kompiliert mit `TEST3x`
- https://onlinegdb.com/JYSW4k1J0
  die `ObserverRegistry` ist hier noch etwas genereller
- https://onlinegdb.com/K9KPvIqoo

*: Im Hinblick auf die klare Heraushebung Unterschiede empfiehlt sich die Verwendung eines Tools, das übersichtliche "Side-by-Side"-Vergeiche von Source erlaubt (wie es z.B. auch in VSCode und Eclipse integriert ist).

Als kurze Zusammenfassung hier nur, dass die Registry (immer noch) auf dem in der Lösung Exercise 3 verwendeten fest dimensionierten C-Array basiert, welches nun den Element-Typs `std::function void(std::ostream&)` hat.

Beim `Attach` wird eine `CallbackID` zurückgeliefert …
… welche ggf. aufbewahrt werden sollte …
… um später ein Eintrag wieder zu löschen.

STL in Beispielen:

https://godbolt.org/z/fahhj69ze (der "word count" Klassiker aus K&R)
https://godbolt.org/z/qexEc4j5T ("word positions – ähnlich wie zuvor)
https://godbolt.org/z/5PdK6znb7 (die "Umkehrung" zum "word positions")
TBD: (STL Algorithmen)

Übung Exercise 5 (Multithreading) aus Kapitel 11
- https://onlinegdb.com/EXbdMDQWlp
Donnerstagvormittag
- Lösung Exercise 5
  https://onlinegdb.com/XQCILvl6s
- Übung Exercise 6 (Mutex-Synchronisation [*])
  https://onlinegdb.com/DpyUzprV7
Donnerstagnachmittag
- Lösung Exercise 6
  https://onlinegdb.com/F_HIAFcSl

*: Hier wird Problematik behandelt, dass die gegenwärtige Implementierung des `ObserverContainer`-s nicht sicher gegen konkurrierende Aufrufe ist, beispielsweise wenn neue Observer registriert werden während die `Notify`-Schleife läuft.

Sammlung weiterer Beispiele mit "Compiler Explorer":

`namespace` und `using`
https://godbolt.org/z/qYrfGbqrf
Alle Demos-Programme aus Kapitel "C++FOR Exceptions":
https://godbolt.org/z/A6bg9U (copy-paste EX-15...18)
https://godbolt.org/z/S4op5a (copy-paste EX-21...24)
https://godbolt.org/z/ve-bBX (copy-paste EX-25)
https://godbolt.org/z/m7K92A (copy-paste EX-26)
https://godbolt.org/z/iYJ4yJ (copy-paste EX-27)
https://godbolt.org/z/WquFzw (copy-paste EX-30...33)
https://godbolt.org/z/5rz1jdWhr (Variante mit `std::out_of_range`)
https://godbolt.org/z/XHtBLn (copy-paste EX-42...44)
https://godbolt.org/z/mdVmeY (copy-paste EX-42..43+45)
https://godbolt.org/z/gejU3B (copy-paste EX-42..43+46)
Demo-Programme zu "State-Machine" aus Kapitel 2
TBD
Entwicklung eines kombinierten Beispiels das u.a. die Verwendung von Templates und Überladung an einem gemeinsamen Beispiel zeigt. Insgesamt gibt es drei Ziele:
1. Ein Makro, der einfach und bequem Testausgaben erzeugt soll durch teilweise Verlagerung in eine `inline`-Funktion übersichticher gestaltet werden.
2. Im Sinne eines einfachen `TDD`-Systems sollen die Ausgaben dieses Makros sollen entfallen, wen sie den Erwartungen entsprechen.
3. EIne Klasse für ganzzahlige arithmetische Datentypen soll im Fall des positiven oder negativen Überlaufs durch einen Fehlerzustand anzeigen und den Wert "am Anschlag" stehen lassen.
Bei den folgenden Entwicklungsschritten ist jeweils eine Ziffer nachgestelt, welche anzeigt, ob dieser Schritt um Ziel (1), (2) oder (3) gehört.
- https://godbolt.org/z/afeWWjjeM (1, 2, 3)
- https://godbolt.org/z/sx676WfoM (1, 2)
- https://godbolt.org/z/bnevj1db6 (3)
- https://godbolt.org/z/b44KEh7Pa (3)
- https://godbolt.org/z/eY3sxc4sT (3)
- https://godbolt.org/z/5YGT16o5G (3)
- https://godbolt.org/z/814T5c11o (2)
- https://godbolt.org/z/M6G71zejb (2)
- https://godbolt.org/z/dqrczhs15 (2)