Modernes C++

This page is the starting point for my blog Modernes C++. A simple overview of my existing and upcoming posts.

This overview serves two purposes. At first, the structure gives you in one view an overview, which posts are already written and how you can find them. At second, I give you an outline of all posts, which will be written. I will successively refine the outline to make the future of this post transparent. This purpose is a more challenging task for me.

Multithreading in modern C++

• Overview

C++ memory model

1. Overview
2. Atomic data types
   1. std::atomic_flag
   2. std::atomic
   3. std::atomic
3. Synchronization and ordering constraints
4. The different C++ memory models
   1. Sequential consistency
      1. Theory
      2. Practice
   2. Acquire-release semantic
      1. Synchronization and ordering constraints
      2. Transitivity
      3. The special case std::memory_order_consume
      4. The typical error
   3. Wait and Sleep
5. Fences
   1. Memory barriers
   2. Acquire- and release memory barriers
   3. Blocking and non-blocking algorithms
   4. ABA - A is not the same as A

The threading interface

1. Threads
   
   1. Creation
   2. Lifetime
   3. Arguments
   4. Sharing data
      
      1. Risks
      2. Locks
      3. Reader-writer locks
      4. Safe initialization
2. Thread-local data
3. Condition variables
4. Tasks
   1. std::async
   2. std::packaged_task
   3. std::promise and std::future
   4. The special futures std::async
5. Condition variables versus tasks for the synchronization of threads
6. Challenges
   1. Data races versus race conditions
   2. Malicous data races
   3. Blocking and non-blocking algorithms

Multithreading with C++17 and C++20

1. An overview
   1. Parallel algorithm of the Standard Template Library
   2. Atomic smart pointers
   3. std::future extensions
   4. Latches and barriers
   5. Coroutines
   6. Transactional memory
   7. Task blocks

Application of multithreading

1. The time library
   1. Overview
   2. Time point
   3. Time duration
   4. Clock
   5. Wait and Sleep
2. Ongoing optimization with CppMem
   
   1. Context of ongoing optimization
   2. Introduction to CppMem
   3. Non atomic variables
   4. Locks
   5. Sequential consistency
   6. Acquire-release semantic
   7. Acquire-release semantic with a data race
   8. Relaxed semantic
   9. volatile
3. Singleton
   1. Thread safe initialization of a singleton
4. Calculating the sum of a std::vector
   
   1. Single threaded
   2. Multithreaded with shared variables
   3. Multithreaded with minimal synchronization
   4. My conclusion

Embedded programming with C++

• Requirements for embedde programming
• Myths and facts

High safety requirements

1. C++11
   1. Automatic type deduction with auto
   2. Prevent narrowing with  {} initialization
   3. Guarantees at compile time with static_assert and the type-traits library
      1. static_assert
      2. Continuesly improvement- An introductionary example to the type-traits library
      3. Check types
      4. Compare and modfy types
   4. User-defined literals
      
      1. Type safe calculation with user-defined literals
      2. Raw and cooked
   5. Strong typed enumerations
   6. override and final
   7. The null poiner constant nullptr

Performance matters

1. C++98
   1. inline
2. C++11
   1. Constant expressions
      
      1. Variables and objects
      2. Functions
   2. Optimization with the type-traits library
   3. Multithreading interface
   4. C++ memory model
   5. Hashtables
      1. Overview
      2. A simple performance comparison
      3. Hash functions
      4. Buckets, capacity and, load factor
   6. Generalized PODs
   7. noexcept
3. C++14
   1. constexpr functions

Careful handling of resources

1. Overview
2. Automatic memory management
   
   1. Smart pointers
      
      1. Memory and performance overhead
      2. std::unique_ptr
      3. std::shared_ptr
         1. std::shared_ptr
         2. Specialities
      4. std::weak_ptr
   2. The STL containers
      1. std::vector and std::string
         
      2. std::array
3. C++ idioms
   
   1. Move semantic
      1. Copy versus move semantic
      2. Two nice properties
   2. Perfect forwarding
   3. RAII idiom
4. Explicit memory managemenet
   
   1. Overloading operator new and delete
      
      1. Part 1
      2. Part 2
   2. std::allocator
   3. Strategies for the allocation of memory
   4. Pros and cons of the various memory allocation strategies
   5. Memory pool allocators from Jonathan Müller

 Functional programming with C++

1. Overview
2. Functional Feature in C++
   1. C++98
   2. TR1 und C++11
   3. Dispatch table and generic Lambdas
   4. C++17 and C++20
3. The definition
4. Characteristics of functional programming
   1. First-class functions
   2. Higher-order functions
   3. Immutable data
   4. Pure functions
   5. Recursion
   6. Manipulation of lists
   7. Lazy evaluation
      1. CRTP
      2. Expression templates
5. Functional programming with C++17 and C++20
   1. Fold expressions
   2. The new ranges library
   3. Concepts
      1. Placeholders
   4. Monads in C++

C++17

1. Core language
   1. More details
2. Library
   1. std::byte
   2. std::filesystem
   3. std::string_view
   4. std::any, std::optional, and std::variant
   5. The new algorithm of the STL
   6. Improved associative containers and uniform container access

What is modern C++?

1. Two highly valuable resources
2. Why do we need guidelines for modern C++?

Go to Leanpub/cpplibrary "What every professional C++ programmer should know about the C++ standard library".   Get your e-book. Support my blog.