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)
6. Das Dining Philsophers Problem
   1. Dining Philosophers Problem I
   2. Dining Philosophers Problem II
   3. Dining Philosophers Problem III

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

Designmuster und Architekturmuster

1. Ein erster Überblick
2. Einführung
   1. Softwareentwicklung: Patterns bringen klare Vorteile
   2. Die Geschichte der Patterns in der Softwareentwicklung
   3. Klassifizierung von Design Patterns in der Softwareentwicklung
   4. Klassifizierung von Patterns in der Softwareentwicklung
3. Begrifflichkeit
   1. Die Struktur von Patterns in der Softwareentwicklung
   2. Patterns in der Softwareentwickling: nicht isoliert, sondern in Beziehung
   3. Softwareentwicklung: Antipattern, die böse Schwester der Design Patterns
4. Design Patterns
   1. Erzeugungsmusters
      1. Fabrikmethode
         1. Softwareentwicklung: Das Design-Pattern Fabrikmethode zum Erzeugen von Objekten
         2. Softwareentwicklung: Design-Pattern Fabrikmethode ohne Probleme
      2. Das Singleton-Pattern
         1. Patterns in der Softwareentwicklung: Das Singleton-Muster
         2. Patterns in der Softwareentwicklung: Die Vor- und Nachteile des Singleton-Musters
         3. Patterns in der Softwareentwicklung: Die Alternativen zum Singleton-Muster
   2. Strukturmuster
      1. Patterns in der Softwareentwicklung: Das Adapter-Muster
      2. Patterns in der Softwareentwicklung: Das Brückenmuster
      3. Patterns in der Softwareentwicklung: Das Decorator-Muster
      4. Patterns in der Softwareentwicklung: Das Kompositum-Muster
      5. Patterns in der Softwareentwicklung: Das Strukturpattern Fassade
      6. Patterns in der Softwareentwicklung: Das Stellvertretermuster
      7. Patterns in der Softwareentwicklung: Das Beobachtermuster
   3. Verhaltensmuster
      1. Patterns in der Softwareentwicklung: Das Besuchermuster
      2. Patterns in der Softwareentwicklung: Die Template-Methode
      3. Patterns in der Softwareentwicklung: Das Strategiemuster
5. Idiome
   1. Allgemein
      1. Idioms in der Softwareentwicklung: Das Copy-and-Swap Idiom
      2. Techniken in der Softwareentwicklung: Partial Function Application
      3. Softwareentwicklung: Argument-Dependent Lookup und Hidden Friend Idiom in C++
   2. Klassen
      1. Programmiersprache C++: Rule of Zero, or Six
      2. Idiome in der Softwareentwicklung: Reguläre Datentypen
      3. Idiome in der Softwareentwicklung: Value-Objekte
      4. Patterns in der Softwreentwicklung: Das Nullobjekt-Entwurfsmuster
      5. Idiome in der Softwareentwicklung: Das Iterator-Protokoll
      6. Idiome in der Softwareentwicklung: Covariant Return Type
   3. Polymorphie
      1. Idiome in der Softwareentwicklung: Polymophie und Templates
   4. Templates
      1. Idiome in der Softwareentwicklung: Polymophie und Templates
6. Architekturpattern
   1. Woran erkannt man eine gute Softwarearchitektur? von Alexander Eisenhuth
   2. Strukturen in der Softwareentwicklung: Architekturmuster
   3. Patterns in der Softwarearchitektur: Das Schichtenmuster
   4. Patterns in der Softwarearchitektur: Das Pipes-and-Filters-Muster
   5. Pattern in der Softwarearchitektur: Das Broker-Muster
   6. Pattern in der Softwarearchitektur: Model-View-Controller
7. Concurrency
   1. Softwareentwicklung: Patterns für nebenläufige Anwendungen
   2. Patterns in der Softwareentwicklung für das Teilen von Daten zwischen Threads
   3. Softwareentwicklung: Umgang mit Veränderung - das Thread-Safe-Interface
   4. Softwareentwicklung: Umgang mit Veränderung - Locking
   5. Softwareentwicklung. Umgang mit Veränderungen - Guarded Suspension
   6. Patterns in der Softwarearchitektur: Das Active Object
   7. Patterns in der Softwarearchitektur: Monitor Object
   8. Fehlerkorrektur zum Beitrag über Monitor Object in der Thread-Safe Queue

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
   7. Parallele Algorithmen der STL mit dem GCC-Compiler
   8. Performance der parallelen STL-Algorithmen
   9. Programmiersprache C++: Benchmark der parallelen STL-Algorithmen
   10. Softwareentwicklung: Polymorphe Allokatoren in C++17
   11. Softwareentwicklung: Spezielle Allokatoren mit C++17
   12. Sofwareentwicklung: Optimierung mit Allokatoren in 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. Definition von Concepts (Logische Kombination von anderen Concepts und Compilezeitprädikaten)
      9. Concepts mit Requires Expressions definieren
      10. Requires Expressions in C++20 direkt verwenden
      11. Die Concept Equal und Ordering definieren
      12. Die Concepts SemiRegular und Regular definieren
      13. Datentypen mit Concepts prüfen - Die Motivation
      14. Datentypen mit Concept prüfen
      15. Concepts in C++20: Eine Evolution oder eine Revolution?
   2. Ranges Bibliothek
      1. Die Ranges Bibliothek
      2. Funktionale Pattern mit der Ranges-Bibliothek
      3. Die Ranges Bibliothek in C++20: Mehr Details
      4. Projektionen mit Ranges
      5. Sentinels und Concepts mit Ranges
      6. Verbesserte Iteratoren mit Ranges
      7. Die Ranges-Bibliothek in C++20: Designentscheidungen
      8. Die Ranges-Bibliothek in C++20: Weitere Designentscheidungen
      9. Pythonisch mit der Ranges-Bibliothek: range und filter
      10. Pythons range-Funktion, die zweite
      11. 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
      9. Softwareentwicklung: Eine kompakte Einführung in Coroutinen von Dian-Lun Li
      10. Coroutinen: Ein Scheduler für Tasks - Teil 2 von Dian-Lun Li
      11. Programmiersprache C++: Ein Prioritäts-Scheduler für Coroutinen
      12. Programmiersprache C++: Ein anspruchsvoller Prioritäts-Scheduler für CoroutinenProgrammiersprache C++: Ein anspruchsvoller Prioritäts-Scheduler für Coroutinen
   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
      6. Private Module Fragment und Header Units
      7. C++20: Modulunterstützung der großen drei Compiler
      8. C++20: Weilere Details zur Modulunterstützung der großen drei Compiler
   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++23

1. C++23: Der neue C++ Standard ist fertig
2. Kernsprache
   1. C++23: Deducing This erstellt explizite Zeiger
   2. C++23: Syntactic Sugar with Deducing This
   3. C++23: Die kleinen Perlen in der Kernsprache
   4. C++23: Mehr kleine Perlen in der Kernsprache
3. Bibliothek
   1. C++23: Ein modularisierte Standardbibliothek und zwei neue Funktionen
   2. Ranges: Verbesserungen mit C++23
   3. C++23: Eine neue Art der Fehlerbehandlung mit std::expected
   4. C++23: Vier neue assoziative Container
   5. C++23: Eine multidemensionale View
   6. C++23: Ranges Verbesserung und std::generator

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
4. Überladen
   1. Überladen von Funktionen und Operatoren I
   2. Überladen von Funktionen und Operatoren II
   1. 1. Unions
   2. Aufzählungen (enums)
   3. Ressourcen
      1. Allgemeine Regeln
      2. Allokieren und Deallokieren von Speicher
      3. Smart Pointer
      4. Smart Pointer als Funktionsparameter
   4. 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
   5. Performanz
      1. Regeln zur Performanz
      2. Mehr Regeln zur Performanz
      3. Die verbleibenden Regeln zum Performanz
   6. 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
   7. 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
   8. Konstanten und zur Unveränderlichkeit
   9. 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
   10. Sourcecode
       1. Quelldateien
       2. Die verbleibenden Regeln zu Quelldateien
       3. Module
       4. Mehr Details zu Modulen
   11. 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
   12. 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. Funktions-Templates
      1. Funtions-Templates
      2. Mehr Details zu explizten Template-Argumenten und Concepts
   2. Klassen-Templates
      
      1. Klassen-Templates
      2. Überraschungen inklusive: Vererbung und Memberfunktionen von Klassen-Templates
   3. Alias Templates und Template Parameter
   4. Template Argumente
      1. Template Arguments
      2. Die automatische Bestimmung der Template Argumente von Klassen-Templates
   5. Template-Spezialisierung
      1. Einführung in die Template-Spezialisierung
      2. Mehr Details zu Klassen-Templates
      3. Vollständige Spezialisierung von Funktions-Templates
3. Details
   1. Template-Instanziierung
   2. Variadic Templates
      1. Variadic Templates oder die Power der drei Punkte
      2. Mehr über Variadic Templates ...
      3. Von Variadic Templates zu Fold Expressions
      4. Clevere Tricks zu Parameterpacks und Fold Expressions
      5. Eine std::variant mit dem Overload Pattern besuchen
   3. Die speziellen Freundschaften von Templates
   4. Abhängige Namen
4. Techniken
   1. Automatischer Rückgabetyp
      1. Automatischer Rückgabetyp (C++98)
      2. Automatischer Rückgabetyp (C++11/14/20)
   2. Template-Metaprogrammierung
      1. Wie alles begann
      2. Wie es funktioniert
      3. Hybride Programmierung
   3. Die Type-Traits Bibliothek
      1. Typprüfungen
      2. Typvergleiche
      3. std::is_base_of
      4. Korrektheit
      5. Optimierung
   4. constexpr
      1. constexpr Funktionen
      2. constexpr und consteval Funktionen in C++20
   5. constexpr if
5. Design
   1. Statische und dynamische Polymorphie
   2. CRTP
      1. Mehr Details zur statischen und dynamischen Polymorphie
      2. Mixins
   3. Temporäre Objekte vermeiden mit Expression Templates
   4. Softwaredesign mit Policies
   5. Softwaredesign mit Traits und Tag Dispatching
   6. Eine std::advance Implementierung mit C++98, C++17 und C++20
   7. Type Erasure

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