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

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

 Was ist modernes  C++?

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

Rezensionen

1. Clean C++

Thanks a lot to my Patreon Supporters: Eric Pederson, Paul Baxter, Franco Amato, and Carlos Gomes Martinho.

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 550 pages full of modern C++ and more than 100 source files presenting concurrency in practice.