In diesem Abschnitt untersuchen wir die Einhaltung des C++-Standards bei verschiedenen Compilern und Frameworks und identifizieren dabei nicht standardkonforme Erweiterungen und praktische Abweichungen, die sich auf die Portabilität und Wartbarkeit von Code in realen Entwicklungsumgebungen auswirken.

In diesem Abschnitt befassen wir uns mit C++ als multiparadigmatischer Sprache, wenden funktionale Programmierung mit std::function an, analysieren Metaprogrammierung mithilfe von Templates und constexpr und entwerfen starke Typen unter Verwendung von Einschränkungen und Typaliasen, um sichereren und besser wartbaren Code zu erzielen.

In diesem Abschnitt befassen wir uns mit dem Startvorgang von Anwendungen, analysieren ELF unter Linux und PE unter Windows, verfolgen den Ablauf von _start() bis main() und nutzen Ghidra, um die Initialisierung zur Laufzeit zu untersuchen und so tiefere Einblicke für die Fehlersuche und die sichere Entwicklung zu gewinnen.

In diesem Abschnitt untersuchen wir, wie entscheidend die Reihenfolge von Klassenmitgliedern und Initialisierungssequenzen in C++ ist, um ein vorhersehbares Verhalten zu gewährleisten, undefinierte Ergebnisse zu vermeiden und zuverlässigen, wartbaren Code in praktischen Anwendungen zu gewährleisten.

In diesem Abschnitt untersuchen wir Fragen der Speicher- und Zeitsicherheit in C++, lernen den Einsatz von `std::span` zur Vermeidung von Pufferüberläufen kennen und analysieren die bestehenden Einschränkungen moderner C++-Mechanismen bei der Beseitigung von undefiniertem Verhalten.

In diesem Abschnitt definieren wir Parallelität und Parallelablauf in C++ unter Verwendung funktionaler Programmierung und des Akteurmodells, gehen dabei auf häufige Herausforderungen ein und zeigen sicherere, besser vorhersehbare Ansätze für skalierbare Hochleistungssysteme auf.

In diesem Abschnitt befassen wir uns mit der Verwendung von Inline-Assembler zur Erzielung maximaler Leistung in C++ auf x86-Architekturen. Dabei lernen wir, die Compiler-Ausgabe zu bewerten und fundierte Entscheidungen darüber zu treffen, wann manuelle Optimierungen sinnvoll sind und wann man sich auf moderne Compiler-Optimierungen verlassen sollte.

In diesem Abschnitt befassen wir uns mit den ästhetischen Qualitäten von C++-Code und legen dabei den Schwerpunkt auf Symmetrie, strukturelle Klarheit und Eleganz bei der Gestaltung von Makros und der Syntax. Dabei wird hervorgehoben, wie Schönheit die Wartbarkeit und die intellektuelle Befriedigung beim Programmieren steigert.

In diesem Abschnitt untersuchen wir das moderne C++-Bibliotheksökosystem und konzentrieren uns dabei auf die Entwicklererfahrung, die Kompatibilität zwischen den Bibliotheken und die Sicherheit der Lieferkette, um zuverlässige und wartbare Software für praktische Anwendungen zu entwickeln.

In diesem Abschnitt befassen wir uns mit der Abwärtskompatibilität von C++ zu C, die eine nahtlose Integration von Legacy-Code ermöglicht. Wir untersuchen praktische Anwendungsfälle der automatischen Typinferenz und der Interoperabilität mit C-Bibliotheken in der modernen Entwicklung auf Systemebene.

In diesem Abschnitt befassen wir uns mit dem Eigentumsmodell, den Sicherheitsfunktionen und dem Trait-System von Rust und zeigen auf, wie diese eine zuverlässige und leistungsstarke Systemprogrammierung als moderne Alternative zu C++ ermöglichen.