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++
C++-Speichermodell
- Überblick
- Atomare Datentypen
- std::atomic_flag
- std::atomic<bool>
- std::atomic
- Synchronisations- und Ordnungsbedingungen
- Die verschiedenen C++-Speichermodelle
- Sequenzielle Konsistenz
- Theorie
- Praxis
- Acquire-Release-Semantik
- Synchronisations- und Ordnungsbedingungen
- Transitivität
- Der Spezialfall std::memory_order_consume
- Ein typischer Fehler
- Relaxed-Semantik
- Fences
- Speicherbarrieren
- Acquire- und release-Speicherbarrieren
Standardisierte Threading-Schnittstelle
- Threads
- Threads erzeugen
- Lebenszeit von Threads
- Datenübergabe an Threads
- Thread teilen Daten
- Gefahren von Mutexen
- Locks
- Reader-Writer Locks
- Sicheres Initialisieren der Daten
- Threadlokale Daten
- Bedingungsvariablen
- Tasks
- std::async
- std::packaged_task
- std::promise und std::future
- Die besonderen Future des std::async
- Bedingungsvariablen versus Tasks zur Synchronisation von Threads
- Herausforderungen
- Race Conditions versus Data Races
- Bösartige Race Conditions und Data Races
- Blockierende und nicht-blockierende Algorithmen
- ABA - A ist nicht gleich A
Multihreading mit C++17 und C++20
- Überblick
- C++17
- Parallel Standard Template Library
- C+++20
- Atomare Smart Pointer
- std::future Erweiterungen
- Latches und Barriers
- Coroutinen
- Transactional Memory
- Task Blöcke
- Executors
- Unified Futures
- std::jthread
Anwendung Multithreading
- Die Zeitbibliothek
- Zeitpunkt
- Zeitdauer
- Zeitgeber
- Sukzessive Optimierung von Variablenzugriffen
- Locks
- Sequenzielle Konsistenz
- Acquire-Release-Semantik
- Relaxed-Semantik
- volatile
- Threadsicheres Initialisieren eines Singletons
- Singleton: To use or not to use
- Die Summe aller Elemente eines std::vector berechnen
- Single-Threaded
- Multithreaded mit einer geteilten Variable
- Multithreaded mit minimaler Synchronisation
- Mein Fazit
- CppMem
- Überblick
- Nicht synchronisierter Zugriff
- Sukzessive Optimierung 1 (Sequenziellen Konsistenz)
- Sukzessive Optimierung 2 (Bruch der Sequenziellen Konsistenz)
- Das Dining Philsophers Problem
- Dining Philosophers Problem I
- Dining Philosophers Problem II
- Dining Philosophers Problem III
Embedded Programmierung mit C++
- C++11
- Automatische Typableitung mit auto
- Verengung verhindern mit {}-Initialisierung
- Zusicherungen zur Compilezeit mit static_assert und der Type-Traits Bibliothek
- Immer sicherer- Ein einführendes Beispiel zur Type-Traits Bibliothek
- Typeigenschaften abfragen
- Typen vergleichend und modifizieren
- Benutzerdefinierte Literale
- Typsicheres Rechnen mit Benutzerdefinierten Literalen
- Raw und Cooked
- Streng typisierte Auszählungstypen
- override und final
- Die Null-Zeiger-Konstante nullptr
- C++98
- inline
- C++11
- Konstante Ausdrücke
- Variablen und Objekte
- Funktionen
- Optimierung mit der Type-Traits Bibliothek
- Multithreading Schnittstelle
- C++-Speichermodell
- Hashtabellen
- Ein einfacher Performanzvergleich
- Hashfunktionen
- Buckets, Kapazität und Ladefaktor
- Erweiterte PODs
- noexcept Bezeichner
- C++14
- constexpr Funktionen
Sorgfältiger Umgang mit Ressourcen
- Automatische Speicherverwaltung
- Smart Pointer
- Speicher- und Performanz Overhead
- std::unique_ptr
- std::shared_ptr
- std::shared_ptr
- Besonderheiten
- std::weak_ptr
- Die STL-Container
- std::vector und std::string
- std::array
- C++-Idiome
- Move-Semantik
- Copy- versus Move-Semantik
- Zwei nette Eigenschaften
- Perfekt Forwarding
- RAII-Idiom
- Explizites Speicherverwaltung
- Globale operator new und delete überladen
- Teil 1
- Teil 2
- std::allocator
- Strategien für das Anfordern von Speicher
- Vor- und Nachteile der verschiedenen Speicherstrategien
- Memory Pool Allokatoren von Jonathan Müller
Funktionale Programmierung mit C++
- Ein einfacher Vergleich: Objektorientierte, generische und funktionale Programmierung
- Funktionale Feature in C++
- C++98
- TR1 und C++11
- Dispatch Table in C++11
- C++17 und C++20
- Definition
- Charakteristiken
- First-Class Funktionen
- Funktionen höherer Ordnung
- Unveränderliche Daten
- Reine Funktionen
- Rekursion
- Manipulation von Listen
- Bedarfsauswertung
- CRTP
- Expression Templates
- Funktionale Programmierung mit C++17 und C++20
- Fold Expressions
- Ranges Bibliothek
- Concepts
- Placeholders
- std::optional
- std::future Erweiterungen
Designmuster und Architekturmuster
- Ein erster Überblick
- Einführung
- Softwareentwicklung: Patterns bringen klare Vorteile
- Die Geschichte der Patterns in der Softwareentwicklung
- Klassifizierung von Design Patterns in der Softwareentwicklung
- Klassifizierung von Patterns in der Softwareentwicklung
- Begrifflichkeit
- Die Struktur von Patterns in der Softwareentwicklung
- Patterns in der Softwareentwickling: nicht isoliert, sondern in Beziehung
- Softwareentwicklung: Antipattern, die böse Schwester der Design Patterns
- Design Patterns
- Erzeugungsmusters
- Fabrikmethode
- Softwareentwicklung: Das Design-Pattern Fabrikmethode zum Erzeugen von Objekten
- Softwareentwicklung: Design-Pattern Fabrikmethode ohne Probleme
- Das Singleton-Pattern
- Patterns in der Softwareentwicklung: Das Singleton-Muster
- Patterns in der Softwareentwicklung: Die Vor- und Nachteile des Singleton-Musters
- Patterns in der Softwareentwicklung: Die Alternativen zum Singleton-Muster
- Strukturmuster
- Patterns in der Softwareentwicklung: Das Adapter-Muster
- Patterns in der Softwareentwicklung: Das Brückenmuster
- Patterns in der Softwareentwicklung: Das Decorator-Muster
- Patterns in der Softwareentwicklung: Das Kompositum-Muster
- Patterns in der Softwareentwicklung: Das Strukturpattern Fassade
- Patterns in der Softwareentwicklung: Das Stellvertretermuster
- Patterns in der Softwareentwicklung: Das Beobachtermuster
- Verhaltensmuster
- Patterns in der Softwareentwicklung: Das Besuchermuster
- Patterns in der Softwareentwicklung: Die Template-Methode
- Patterns in der Softwareentwicklung: Das Strategiemuster
- Idiome
- Allgemein
- Idioms in der Softwareentwicklung: Das Copy-and-Swap Idiom
- Techniken in der Softwareentwicklung: Partial Function Application
- Softwareentwicklung: Argument-Dependent Lookup und Hidden Friend Idiom in C++
- Klassen
- Programmiersprache C++: Rule of Zero, or Six
- Idiome in der Softwareentwicklung: Reguläre Datentypen
- Idiome in der Softwareentwicklung: Value-Objekte
- Patterns in der Softwreentwicklung: Das Nullobjekt-Entwurfsmuster
- Idiome in der Softwareentwicklung: Das Iterator-Protokoll
- Idiome in der Softwareentwicklung: Covariant Return Type
- Polymorphie
- Idiome in der Softwareentwicklung: Polymophie und Templates
- Templates
- Idiome in der Softwareentwicklung: Polymophie und Templates
- Architekturpattern
- Woran erkannt man eine gute Softwarearchitektur? von Alexander Eisenhuth
- Strukturen in der Softwareentwicklung: Architekturmuster
- Patterns in der Softwarearchitektur: Das Schichtenmuster
- Patterns in der Softwarearchitektur: Das Pipes-and-Filters-Muster
- Pattern in der Softwarearchitektur: Das Broker-Muster
- Pattern in der Softwarearchitektur: Model-View-Controller
- Concurrency
- Softwareentwicklung: Patterns für nebenläufige Anwendungen
- Patterns in der Softwareentwicklung für das Teilen von Daten zwischen Threads
- Softwareentwicklung: Umgang mit Veränderung - das Thread-Safe-Interface
- Softwareentwicklung: Umgang mit Veränderung - Locking
- Softwareentwicklung. Umgang mit Veränderungen - Guarded Suspension
- Patterns in der Softwarearchitektur: Das Active Object
- Patterns in der Softwarearchitektur: Monitor Object
- Fehlerkorrektur zum Beitrag über Monitor Object in der Thread-Safe Queue
C++17
- Kernsprache
- Mehr Details
- Bibliothek
- std::byte
- std::filesystem
- std::string_view
- std::any, std::optional, and std::variant
- Neue Algorithmen in der STL
- Verbesserte Container mit C++17
- Parallele Algorithmen der STL mit dem GCC-Compiler
- Performance der parallelen STL-Algorithmen
- Programmiersprache C++: Benchmark der parallelen STL-Algorithmen
- Softwareentwicklung: Polymorphe Allokatoren in C++17
- Das nächste große Ding: C++20
- Überblick
- Die großen Neuerungen
- Die Kernsprache
- Die Bibliothek
- Concurrency
- Details
- Concepts
- Zwei Extreme und die Rettung dank Concepts
- Die Details
- Die Placeholder Syntax
- Syntactic Sugar
- Was wir nicht bekommen
- Vordefinierte Conceps
- Concepts definieren
- Definition von Concepts (Logische Kombination von anderen Concepts und Compilezeitprädikaten)
- Concepts mit Requires Expressions definieren
- Requires Expressions in C++20 direkt verwenden
- Die Concept Equal und Ordering definieren
- Die Concepts SemiRegular und Regular definieren
- Datentypen mit Concepts prüfen - Die Motivation
- Datentypen mit Concept prüfen
- Concepts in C++20: Eine Evolution oder eine Revolution?
- Ranges Bibliothek
- Die Ranges Bibliothek
- Funktionale Pattern mit der Ranges-Bibliothek
- Die Ranges Bibliothek in C++20: Mehr Details
- Projektionen mit Ranges
- Sentinels und Concepts mit Ranges
- Verbesserte Iteratoren mit Ranges
- Pythonisch mit der Ranges-Bibliothek: range und filter
- Pythons range-Funktion, die zweite
- Die map-Funktion von Python
- Couroutinen
- Ein erster Überblick
- Mehr Details
- Ein unendlicher Datenstrom mit Coroutinen
- Thread-Synchronisation mit Coroutinen
- cppcoro
- Coroutinen mit cppcoro
- Mächtige Coroutinen mit cppcoro
- Thread-Pools mit cppcoro
co_return
- Einfache Futures mit Coroutinen implementieren
- Lazy Futures mit Coroutinen
- Mit Coroutinen einen Future in einem eigenen Thread ausführen
- co_yield
- Ein unendlicher Datenstrom dank Coroutinen in C++20
- Ein generischer Datenstrom mit Coroutinen
- co_await
- Jobs starten mit Coroutinen
- Automatisches Fortsetzen eines Jobs auf einem anderen Thread
- Module
- Die Vorteile von Modulen
- Ein einfaches math Modul
- Module Interface Unit und Module Implementation Unit
- Module strukturieren
- Weitere offene Fragen zu Modulen
- Private Module Fragment und Header Units
- Die Kernsprache
- Der Drei-Weg-Vergleichsoperator
- Der Drei-Weg-Vergleichsoperator
- Mehr Details zum Spaceship Operator
- Optimierte Vergleiche mit dem Spaceship Operator
- Designated Initializers
- consteval und constinit
- Die Lösung des Static Initialization Order Fiasco
- Verschiedene Template Verbesserungen mit C++20
- Mächtigere Lambda-Ausdrücke mit C++20
- Mehr Lambda-Features mit C++20
- Neue Attribute mit C++20
- volatile und andere kleine Verbesserungen in C++20
- Die Bibliothek
- Geschützter Zugriff auf Sequenzen von Objekten mit std::span
- constexpr std::vector und std::string mit C++20
- Neue praktische Funktionen für Container in C++20
- std::format
- Die Grundfunktionalität
- std::format um benutzterdefinierte Datentypen erweitern
- Noch mehr praktische Werkzeuge in C++20
- Kalender und Zeitzonen
- Tageszeit
- Kalendertage
- Umgang mit Kalendertagen
- Zeitzonen
- Sicherer Vergleich von Integralen
- Prüfen von C++-Features
- Bit-Manipulationen mit C++20
- Concurrency
- Atomics
- Referenzen
- Synchronisation mit atomaren Variablen
- Performanzvergleich von Bedingungsvariablen und Atomics
- Atomare Smart Pointer
- Semaphoren
- Latches
- Barrieren
- Kooperatives Unterbrechen eines Threads
- std::jthread
- Synchronisierte Ausgabe-Streams
C++23
- C++23: Der neue C++ Standard ist fertig
- Kernsprache
- C++23: Deducing This erstellt explizite Zeiger
- C++23: Syntactic Sugar with Deducing This
- C++23: Die kleinen Perlen in der Kernsprache
- C++23: Mehr kleine Perlen in der Kernsprache
- Bibliothek
- C++23: Ein modularisierte Standardbibliothek und zwei neue Funktionen
- Ranges: Verbesserungen mit C++23
- C++23: Eine neue Art der Fehlerbehandlung mit
std::expected
- C++23: Vier neue assoziative Container
- C++23: Eine multidemensionale View
- C++23: Ranges Verbesserung und
std::generator
- Zwei wervolle Ressourcen
- Warum benötigen wir Richtlinien für modernes C++?
- The C++ Core Guidelines
- Die Philosophie
- Interfaces I
- Interfaces II
- Guideline Support Library
- Funktionen
- Definition
- Funktionsparameter
- Syntax
- Semantik
- Klassen
- Allgemeine Regeln
- Die Nuller-, Fünfer- oder Sechserregel
- Destruktoren
- Konstruktoren
- Verschieben und Kopieren
- Vergleiche und die Funktionen swap und hash
- Funktionsobjekte und Lambdas
- Hierarchien
- Allgemeine Regeln
- Spezielle Regeln I
- Spezielle Regeln II
- Zugriff auf Objekte
- Überladen
- Überladen von Funktionen und Operatoren I
- Überladen von Funktionen und Operatoren II
- Unions
- Aufzählungen (enums)
- Ressourcen
- Allgemeine Regeln
- Allokieren und Deallokieren von Speicher
- Smart Pointer
- Smart Pointer als Funktionsparameter
- Ausdrücke und Anweisungen
- Deklarationen
- Deklarationen und die Initialisierung
- Mehr Regeln zu Deklarationen
- Expressions
- Expressons (Zeiger)
- Regeln für Konvertierungen und Casts
- Regeln zu Don'ts (std::move und Slicing)
- Regeln für Anweisungen
- To Switch or not to Switch, that is the Question
- Mehr zu Kontrollstrukturen
- Regeln zur Arithmetik
- Performanz
- Regeln zur Performanz
- Mehr Regeln zur Performanz
- Die verbleibenden Regeln zum Performanz
- Concurrency und Parallelität
- Regeln zur Concurrency und zur Parallelität
- Mehr Regeln zur Concurrency und zur Parallelität
- Validieren von Concurrent-Code
- Teilen von Daten zwischen Threads
- Sich um Kinder-Threads kümmern
- Mehr Fallen in der Concurrency
- Sei dir der Gefahren von Bedingungsvariablen bewußt
- Concurrency und lock-freies Programmieren
- Die Auflösung des Rätsels
- Die verbleibenden Regeln zur lock-freien Programmierung
- Error Handling
- Regeln zur Fehlerbehandlung
- Ein kleiner Umweg über Kontrakte
- Der noexcept-Spezifier und -Operator
- Regeln zur Ausnahmebehandlung
- finally in C++
- goto considered evil
- Konstanten und zur Unveränderlichkeit
- Templates und generische Programmierung
- Regeln zu Templates und generischer Programmierung
- Type Erasure
- Type Erasure mit Templates
- Besser spezifisch oder generisch
- Regeln zur Verwendung von Concepts
- Regeln zur Definition von Concepts
- Regeln zur Defintion von Concepts 2
- Übergabe von Funktionsobjekten als Operationen
- Interfaces von Templates
- Reguläre und Semireguläre Datentypen
- Ordnung von benutzerdefinierten Typen
- Regeln zu Templates und Ableitungshierarchien
- Regeln zu Variadic Templates
- Regeln zur Template-Metaprogrammierung
- Programmierung zur Compilezeit
- Programmierung zur Compilezeit mit der Type-Traits-Bibliothek
- Programmierung zur Compilezeit mit der Type-Traits-Bibliothek II
- Programmierung zur Compilezeit mit constexpr
- Weitere Regeln zu Templates Modernes C++
- Überraschung inklusive mit der Spezialisierung von Funktions-Templates
- Missverständnisse und Überraschungen
- Typen, Nichttypen und Templates als Template-Parameter
- Sourcecode
- Quelldateien
- Die verbleibenden Regeln zu Quelldateien
- Module
- Mehr Details zu Modulen
- Die Standard Bibliothek
- Die Standard Bibliothek
- std::array und std::vector sind die erste Wahl
- Mehr besondere Freunde mit std::map und std::unordered_map
- Greife nicht über den Container hinaus
- Regeln zu Strings
- Ein- und Ausgabe-Streams
- Wissen zu Ein- und Ausgabestreams
- "The Regular Expression"-Bibliothek
- Mehr Regeln zu Regulären Ausdrücken
- Wenn RAII versagt
- Unterstützende Abschnitte
- Architectural Ideas
- Nichtregeln und Mythen
- Mehr Nichtregeln und Mythen
- Mythen der Blog-Leser
- Mehr Mythen der Blog-Leser
- Profile
- Type Safety
- Type Safety by Design
- Bounds Safety
- Lifetime Safety und die Regeln prüfen
- Regeln zu den Namen und zum Layout des Codes
Templates
- Erste Schritte
- Grundlagen
- Funktions-Templates
- Funtions-Templates
- Mehr Details zu explizten Template-Argumenten und Concepts
- Klassen-Templates
- Klassen-Templates
- Überraschungen inklusive: Vererbung und Memberfunktionen von Klassen-Templates
- Alias Templates und Template Parameter
- Template Argumente
- Template Arguments
- Die automatische Bestimmung der Template Argumente von Klassen-Templates
- Template-Spezialisierung
- Einführung in die Template-Spezialisierung
- Mehr Details zu Klassen-Templates
- Vollständige Spezialisierung von Funktions-Templates
- Details
- Template-Instanziierung
- Variadic Templates
- Variadic Templates oder die Power der drei Punkte
- Mehr über Variadic Templates ...
- Von Variadic Templates zu Fold Expressions
- Clevere Tricks zu Parameterpacks und Fold Expressions
- Eine std::variant mit dem Overload Pattern besuchen
- Die speziellen Freundschaften von Templates
- Abhängige Namen
- Techniken
- Automatischer Rückgabetyp
- Automatischer Rückgabetyp (C++98)
- Automatischer Rückgabetyp (C++11/14/20)
- Template-Metaprogrammierung
- Wie alles begann
- Wie es funktioniert
- Hybride Programmierung
- Die Type-Traits Bibliothek
- Typprüfungen
- Typvergleiche
std::is_base_of
- Korrektheit
- Optimierung
constexpr
constexpr
Funktionen
constexpr
und consteval
Funktionen in C++20
constexpr if
- Design
- Statische und dynamische Polymorphie
- CRTP
- Mehr Details zur statischen und dynamischen Polymorphie
- Mixins
- Temporäre Objekte vermeiden mit Expression Templates
- Softwaredesign mit Policies
- Softwaredesign mit Traits und Tag Dispatching
- Eine
std::advance
Implementierung mit C++98, C++17 und C++20
- Type Erasure
Rezensionen
- Clean C++
C++ Insights
- Implizite Konvertierungen
- Automatische Typableitung
- Template-Instanziierung
- Variadic Templates
- Lambdas
News
- CppCon 2018
- Meeting Embedded und Meeting C++2018
- 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
|
Weiterlesen...