Modernes C++

Der Einstieg in den Blog Modernes C++. Eine einfache Übersicht zu allen bestehenden und kommenden Artikeln.

Diese Übersicht verfolgt zwei Ziele. Das erste Ziel ist offensichtlich. Durch die Struktur siehst du direkt, welche Artikel bisher geschrieben wurden und wie diese einfach zu finden sind. Das zweite Ziel ist schon deutlich anspruchsvoller - vor allem für mich. Ich werde in diesem Artikel sukzessiv die Gliederung entwerfen, damit klar ist, wohin die Reise mit diesem Blog weitergehen wird. Das heißt zum einen, ich werde die Struktur immer weiter verfeinern, das heißt zum anderen, ich werde die nackte Struktur immer weiter mit Fleisch unterfüttern.

Multithreading in modernem C++

• Überblick

C++-Speichermodell

1. Überblick
2. Atomare Datentypen
   1. std::atomic_flag
   2. std::atomic<bool>
   3. std::atomic
3. Synchronisations- und Ordnungsbedingungen
4. Die verschiedenen C++-Speichermodelle
   1. Sequenzielle Konsistenz
      1. Theorie
      2. Praxis
   2. Acquire-Release-Semantik
      1. Synchronisations- und Ordnungsbedingungen
      2. Transitivität
      3. Der Spezialfall std::memory_order_consume
      4. Ein typischer Fehler
   3. Relaxed-Semantik
5. Fences
   1. Speicherbarrieren
   2. Acquire- und release-Speicherbarrieren

Standardisierte Threading-Schnittstelle

1. Threads
   
   1. Threads erzeugen
   2. Lebenszeit von Threads
   3. Datenübergabe an Threads
   4. Thread teilen Daten
      
      1. Gefahren von Mutexen
      2. Locks
      3. Reader-Writer Locks
      4. Sicheres Initialisieren der Daten
2. Threadlokale Daten
3. Bedingungsvariablen
4. Tasks
   1. std::async
   2. std::packaged_task
   3. std::promise und std::future
   4. Die besonderen Future des std::async
5. Bedingungsvariablen versus Tasks zur Synchronisation von Threads
6. Herausforderungen
   1. Race Conditions versus Data Races
   2. Bösartige Race Conditions und Data Races
   3. Blockierende und nicht-blockierende Algorithmen
   4. ABA - A ist nicht gleich A

Multihreading mit C++17 und C++20

1. Überblick
2. C++17
   1. Parallel Standard Template Library
3. C+++20
   1. Atomare Smart Pointer
   2. std::future Erweiterungen
   3. Latches und Barriers
   4. Coroutinen
   5. Transactional Memory
   6. Task Blöcke
   7. Executors
   8. Unified Futures
   9. std::jthread

Anwendung Multithreading

1. Die Zeitbibliothek
   
   1. Zeitpunkt
   2. Zeitdauer
   3. Zeitgeber
2. Sukzessive Optimierung von Variablenzugriffen
   
   1. Locks
   2. Sequenzielle Konsistenz
   3. Acquire-Release-Semantik
   4. Relaxed-Semantik
   5. volatile
3. Threadsicheres Initialisieren eines Singletons
   1. Singleton: To use or not to use
4. Die Summe aller Elemente eines std::vector berechnen
   1. Single-Threaded
   2. Multithreaded mit einer geteilten Variable
   3. Multithreaded mit minimaler Synchronisation
   4. Mein Fazit
5. CppMem
   1. Überblick
   2. Nicht synchronisierter Zugriff
   3. Sukzessive Optimierung 1 (Sequenziellen Konsistenz)
   4. Sukzessive Optimierung 2 (Bruch der Sequenziellen Konsistenz)

Embedded Programmierung mit C++

• Anforderungen der embedded Programmierung
• Mythen und Fakten

Hohe Sicherheitsanforderungen

1. C++11
   1. Automatische Typableitung mit auto
   2. Verengung verhindern mit {}-Initialisierung
   3. Zusicherungen zur Compilezeit mit static_assert und der Type-Traits Bibliothek
      1. Immer sicherer- Ein einführendes Beispiel zur Type-Traits Bibliothek
      2. Typeigenschaften abfragen
      3. Typen vergleichend und modifizieren
   4. Benutzerdefinierte Literale
      1. Typsicheres Rechnen mit Benutzerdefinierten Literalen
      2. Raw und Cooked
   5. Streng typisierte Auszählungstypen
   6. override und final
   7. Die Null-Zeiger-Konstante nullptr

Performanz zählt

1. C++98
   1. inline
2. C++11
   1. Konstante Ausdrücke
      1. Variablen und Objekte
      2. Funktionen
   2. Optimierung mit der Type-Traits Bibliothek
   3. Multithreading Schnittstelle
   4. C++-Speichermodell
   5. Hashtabellen
      1. Ein einfacher Performanzvergleich
      2. Hashfunktionen
      3. Buckets, Kapazität und Ladefaktor
   6. Erweiterte PODs
   7. noexcept Bezeichner
3. C++14
   1. constexpr Funktionen

Sorgfältiger Umgang mit Ressourcen

1. Automatische Speicherverwaltung
   1. Smart Pointer
      
      1. Speicher- und Performanz Overhead
      2. std::unique_ptr
      3. std::shared_ptr
         1. std::shared_ptr
         2. Besonderheiten
      4. std::weak_ptr
   2. Die STL-Container
      1. std::vector und std::string
         
      2. std::array
2. C++-Idiome
   
   1. Move-Semantik
      1. Copy- versus Move-Semantik
      2. Zwei nette Eigenschaften
   2. Perfekt Forwarding
   3. RAII-Idiom
3. Explizites Speicherverwaltung
   
   1. Globale operator new und delete überladen
      
      1. Teil 1
      2. Teil 2
   2. std::allocator
   3. Strategien für das Anfordern von Speicher
   4. Vor- und Nachteile der verschiedenen Speicherstrategien
   5. Memory Pool Allokatoren von Jonathan Müller

Funktionale Programmierung mit C++

1. Ein einfacher Vergleich: Objektorientierte, generische und funktionale Programmierung
2. Funktionale Feature in C++
   
   1. C++98
   2. TR1 und C++11
   3. Dispatch Table in C++11
   4. C++17 und C++20
3. Definition
4. Charakteristiken
   1. First-Class Funktionen
   2. Funktionen höherer Ordnung
   3. Unveränderliche Daten
   4. Reine Funktionen
   5. Rekursion
   6. Manipulation von Listen
   7. Bedarfsauswertung
      1. CRTP
      2. Expression Templates
5. Funktionale Programmierung mit C++17 und C++20
   1. Fold Expressions
   2. Ranges Bibliothek
   3. Concepts
      1. Placeholders
   4. std::optional
   5. std::future Erweiterungen

C++17

1. Kernsprache
   1. Mehr Details
2. Bibliothek
   1. std::byte
   2. std::filesystem
   3. std::string_view
   4. std::any, std::optional, and std::variant
   5. Neue Algorithmen in der STL
   6. Verbesserte Container mit C++17

C++20

1. Das nächste große Ding: C++20
2. Überblick
   1. Die großen Neuerungen
   2. Die Kernsprache
   3. Die Bibliothek
   4. Concurrency
3. Details
   1. Concepts
      1. Zwei Extreme und die Rettung dank Concepts
      2. Die Details
      3. Die Placeholder Syntax
      4. Syntactic Sugar
      5. Was wir nicht bekommen
      6. Vordefinierte Conceps
      7. Concepts definieren
      8. Die Concept Equal und Ordering definieren
      9. Die Concepts SemiRegular und Regular definieren
      10. Concepts in C++20: Eine Evolution oder eine Revolution?
   2. Ranges Bibliothek
      1. Die Ranges Bibliothek
      2. Funktionale Pattern mit der Ranges-Bibliothek
      3. Pythonisch mit der Ranges-Bibliothek: range und filter
      4. Pythons range-Funktion, die zweite
      5. Die map-Funktion von Python
   3. Couroutinen
      1. Ein erster Überblick
      2. Mehr Details
      3. Ein unendlicher Datenstrom mit Coroutinen
      4. Thread-Synchronisation mit Coroutinen
      5. cppcoro
         1. Coroutinen mit cppcoro
         2. Mächtige Coroutinen mit cppcoro
         3. Thread-Pools mit cppcoro
      6. co_return
         1. Einfache Futures mit Coroutinen implementieren
         2. Lazy Futures mit Coroutinen
         3. Mit Coroutinen einen Future in einem eigenen Thread ausführen
      7. co_yield
         1. Ein unendlicher Datenstrom dank Coroutinen in C++20
         2. Ein generischer Datenstrom mit Coroutinen
      8. co_await
         1. Jobs starten mit Coroutinen
         2. Automatisches Fortsetzen eines Jobs auf einem anderen Thread
   4. Module
      1. Die Vorteile von Modulen
      2. Ein einfaches math Modul
      3. Module Interface Unit und Module Implementation Unit
      4. Module strukturieren
      5. Weitere offene Fragen zu Modulen
   5. Die Kernsprache
      1. Der Drei-Weg-Vergleichsoperator
         
         1. Der Drei-Weg-Vergleichsoperator
         2. Mehr Details zum Spaceship Operator
         3. Optimierte Vergleiche mit dem Spaceship Operator
      2. Designated Initializers
      3. consteval und constinit
      4. Die Lösung des Static Initialization Order Fiasco
      5. Verschiedene Template Verbesserungen mit C++20
      6. Mächtigere Lambda-Ausdrücke mit C++20
      7. Mehr Lambda-Features mit C++20
      8. Neue Attribute mit C++20
      9. volatile und andere kleine Verbesserungen in C++20
   6. Die Bibliothek
      1. Geschützter Zugriff auf Sequenzen von Objekten mit std::span
      2. constexpr std::vector und std::string mit C++20
      3. Neue praktische Funktionen für Container in C++20
      4. std::format
         1. Die Grundfunktionalität
         2. std::format um benutzterdefinierte Datentypen erweitern
      5. Noch mehr praktische Werkzeuge in C++20
      6. Kalender und Zeitzonen
         1. Tageszeit
         2. Kalendertage
         3. Umgang mit Kalendertagen
         4. Zeitzonen
      7. Sicherer Vergleich von Integralen
      8. Prüfen von C++-Features
      9. Bit-Manipulationen mit C++20
   7. Concurrency
      1. Atomics
         1. Referenzen
         2. Synchronisation mit atomaren Variablen
         3. Performanzvergleich von Bedingungsvariablen und Atomics
         4. Atomare Smart Pointer
      2. Semaphoren
      3. Latches
      4. Barrieren
      5. Kooperatives Unterbrechen eines Threads
      6. std::jthread
      7. Synchronisierte Ausgabe-Streams

C++ Core Guidelines

1. Zwei wervolle Ressourcen
2. Warum benötigen wir Richtlinien für modernes C++?
3. The C++ Core Guidelines
   1. Die Philosophie
   2. Interfaces I
   3. Interfaces II
   4. Guideline Support Library
   5. Funktionen
      1. Definition
      2. Funktionsparameter
         1. Syntax
         2. Semantik
   6. Klassen
      1. Allgemeine Regeln
      2. Die Nuller-, Fünfer- oder Sechserregel
      3. Destruktoren
      4. Konstruktoren
      5. Verschieben und Kopieren
      6. Vergleiche und die Funktionen swap und hash
      7. Funktionsobjekte und Lambdas
      8. Hierarchien
         1. Allgemeine Regeln
         2. Spezielle Regeln I
         3. Spezielle Regeln II
         4. Zugriff auf Objekte
      9. Überladen
         1. Überladen von Funktionen und Operatoren I
         2. Überladen von Funktionen und Operatoren II
      10. Unions
   7. Aufzählungen (enums)
   8. Ressourcen
      1. Allgemeine Regeln
      2. Allokieren und Deallokieren von Speicher
      3. Smart Pointer
      4. Smart Pointer als Funktionsparameter
   9. Ausdrücke und Anweisungen
      1. Deklarationen
      2. Deklarationen und die Initialisierung
      3. Mehr Regeln zu Deklarationen
      4. Expressions
      5. Expressons (Zeiger)
      6. Regeln für Konvertierungen und Casts
      7. Regeln zu Don'ts (std::move und Slicing)
      8. Regeln für Anweisungen
      9. To Switch or not to Switch, that is the Question
      10. Mehr zu Kontrollstrukturen
      11. Regeln zur Arithmetik
   10. Performanz
       1. Regeln zur Performanz
       2. Mehr Regeln zur Performanz
       3. Die verbleibenden Regeln zum Performanz
   11. Concurrency und Parallelität
       1. Regeln zur Concurrency und zur Parallelität
       2. Mehr Regeln zur Concurrency und zur Parallelität
       3. Validieren von Concurrent-Code
       4. Teilen von Daten zwischen Threads
       5. Sich um Kinder-Threads kümmern
       6. Mehr Fallen in der Concurrency
       7. Sei dir der Gefahren von Bedingungsvariablen bewußt
       8. Concurrency und lock-freies Programmieren
       9. Die Auflösung des Rätsels
       10. Die verbleibenden Regeln zur lock-freien Programmierung
   12. Error Handling
       1. Regeln zur Fehlerbehandlung
       2. Ein kleiner Umweg über Kontrakte
       3. Der noexcept-Spezifier und -Operator
       4. Regeln zur Ausnahmebehandlung
       5. finally in C++
       6. goto considered evil
       7. Regeln zu Konstanten und zur Uneränderlichkeit
   13. Templates und generische Programmierung
       1. Regeln zu Templates und generischer Programmierung
       2. Type Erasure
       3. Type Erasure mit Templates
       4. Besser spezifisch oder generisch
       5. Regeln zur Verwendung von Concepts
       6. Regeln zur Definition von Concepts
       7. Regeln zur Defintion von Concepts 2
       8. Übergabe von Funktionsobjekten als Operationen
       9. Interfaces von Templates
       10. Reguläre und Semireguläre Datentypen
       11. Ordnung von benutzerdefinierten Typen
       12. Regeln zu Templates und Ableitungshierarchien
       13. Regeln zu Variadic Templates
       14. Regeln zur Template-Metaprogrammierung
       15. Programmierung zur Compilezeit
       16. Programmierung zur Compilezeit mit der Type-Traits-Bibliothek
       17. Programmierung zur Compilezeit mit der Type-Traits-Bibliothek II
       18. Programmierung zur Compilezeit mit constexpr
       19. Weitere Regeln zu Templates Modernes C++
       20. Überraschung inklusive mit der Spezialisierung von Funktions-Templates
       21. Missverständnisse und Überraschungen
       22. Typen, Nichttypen und Templates als Template-Parameter
   14. Sourcecode
       1. Quelldateien
       2. Die verbleibenden Regeln zu Quelldateien
       3. Module
       4. Mehr Details zu Modulen
   15. Die Standard Bibliothek
       1. Die Standard Bibliothek
       2. std::array und std::vector sind die erste Wahl
       3. Mehr besondere Freunde mit std::map und std::unordered_map
       4. Greife nicht über den Container hinaus
       5. Regeln zu Strings
       6. Ein- und Ausgabe-Streams
       7. Wissen zu Ein- und Ausgabestreams
       8. "The Regular Expression"-Bibliothek
       9. Mehr Regeln zu Regulären Ausdrücken
       10. Wenn RAII versagt
   16. Unterstützende Abschnitte
       1. Architectural Ideas
       2. Nichtregeln und Mythen
          1. Mehr Nichtregeln und Mythen
          2. Mythen der Blog-Leser
          3. Mehr Mythen der Blog-Leser
       3. Profile
          1. Type Safety
          2. Type Safety by Design
          3. Bounds Safety
          4. Lifetime Safety und die Regeln prüfen
       4. Regeln zu den Namen und zum Layout des Codes

Templates

1. Erste Schritte
2. Grundlagen
   1. Funtions-Templates
   2. Mehr Details zu explizten Template-Argumenten und Concepts

Rezensionen

1. Clean C++

C++ Insights

1. Implizite Konvertierungen
2. Automatische Typableitung
3. Template-Instanziierung
4. Variadic Templates
5. Lambdas

News

1. CppCon 2018
2. Meeting Embedded und Meeting C++2018
3. Quo Vadis - Modernes C++

Thanks a lot to my Patreon Supporters: Paul Baxter,  Meeting C++, Matt Braun, Avi Lachmish, Roman Postanciuc, Venkata Ramesh Gudpati, Tobias Zindl, Dilettant, Marko, Ramesh Jangama, G Prvulovic, Reiner Eiteljörge, Benjamin Huth, and Reinhold Dröge.

Thanks in particular to: 

Get your e-book at Leanpub:

The C++ Standard Library		Concurrency With Modern C++		Get Both as one Bundle
With C++11, C++14, and C++17 we got a lot of new C++ libraries. In addition, the existing ones are greatly improved. The key idea of my book is to give you the necessary information to the current C++ libraries in about 200 pages.		C++11 is the first C++ standard that deals with concurrency. The story goes on with C++17 and will continue with C++20. I'll give you a detailed insight in the current and the upcoming concurrency in C++. This insight includes the theory and a lot of practice with more the 100 source files.		Get my books "The C++ Standard Library" (including C++17) and "Concurrency with Modern C++" in a bundle. In sum, you get more than 600 pages full of modern C++ and more than 100 source files presenting concurrency in practice.

Get your interactive course
Modern C++ Concurrency in Practice	C++ Standard Library including C++14 & C++17
Based on my book "Concurrency with Modern C++" educative.io created an interactive course. What's Inside? 140 lessons 110 code playgrounds => Runs in the browser 78 code snippets 55 illustrations	Based on my book "The C++ Standard Library" educative.io created an interactive course. What's Inside? 149 lessons 111 code playgrounds => Runs in the browser 164 code snippets 25 illustrations