Contributions

Article
The idea of this post is quite simple. I want to visualize templates and, in particular, the process of template instantiation. Thanks to C++ Insights, this visualization is pretty easy.
Article
The future of C++ speaks templates, and so does my blog Modernes C++. Based on the poll of my last post "Quo Vadis - Modernes C++", my next presumably 50 - 100 posts explain the details to templates. In this post, I want to give you an idea of the upcoming posts.
Article
DONE: I have written almost 100 posts about C++20. Now, I want to ask you the question: What should be my next big topic? Make your choice in this poll.

Now, let me take about the future of Modernes C++. I have three ideas in my mind: C++23, extending and embedding Python with C/C++, and templates. The poll is open for one week including the 24.04. This means, in my next post I present your favorite and my plan to write about it.
Article
In my last post "Starting Jobs with Coroutines", I applied co_await to start a job. In this post, I improve the workflow and automatically resume a job if necessary. In my final step, I resume the job on a separate thread.
Article
C++20 has three new keywords to make a coroutine out of a function: co_return, co_yield, and co_await. co_await requires an Awaitable as arguments and starts the Awaiter workflow. Let me show in this post, what that means.
Article
In my last post in this mini-series to coroutines from the practical perspective, I presented the workflow of "An Infinite Data Stream with Coroutines in C++20". In this post, I use the generic potential of the data stream.
Article
In this post, I analyze the new keyword co_yield. Thanks to co_yield, you can create an infinite data stream in C++20.
Article
This post concludes my posts about co_return in C++20. I started with an eager future, continued with a lazy future. Today, I execute the future in a separate thread using coroutines as an implementation detail.
Article
Based on the coroutine-based implementation of a simple future in my last post "Implementing Simple Futures with Coroutines", I want to go today one big step further. I analyze the workflow of the simple future and make it lazy.
Article
Instead of return, a coroutine uses co_return returning its result. In this post, I want to implement a simple coroutine using co_return.
Update
What happens when you write without synchronization to std::cout? You get a mess. With C++20, this should not be anymore.
Article
What happens when you write without synchronization to std::cout? You get a mess. With C++20, this should not be anymore.
Article
std::jthread stands for joining thread. In addition to std::thread (C++11), std::jthread automatically joins in its destructor and can cooperatively be interrupted. Read in this post to know why std::jthread should be your first choice.
Article
A typical question in my C++ seminars is: Can A thread be killed?. Before C++20, my answer is no. With C++20, you can ask a thread politely for its interruption.
Article
In my last post, I introduced latches in C++20. A latch enables it threads to wait until a counter becomes zero. Additionally to a latch, its big sibling barrier can be used more than once. Today, I write about barriers and present atomic smart pointers.
Article
Latches and barriers are coordination types that enable some threads to wait until a counter becomes zero. You can use a std::latch only once, but you can use a std::barrier more than once. Today, I have a closer look at latches.
Article
Semaphores are a synchronization mechanism used to control concurrent access to a shared resource. They also allow it to play ping-pong.
Article
After the introduction to std::atomic_flag in my last post Synchronization with Atomics in C++20, I want to dive deeper. Today, I create a ping-pong game using condition variables, std::atomic_flag, and std::atomic. Let's play.
Article
Sender/receiver workflows are quite common for threads. In such a workflow, the receiver is waiting for the sender's notification before it continues to work. There are various ways to implement these workflows. With C++11, you can use condition variables or promise/future pairs; with C++20, you can use atomics.
Article
Atomics receives a few important extensions in C++20. Today, I start with the new data type std::atomic_ref.
Article
This post concludes my presentation of library features in C++20. Today I write about the class std::source_location and a few functions for bit manipulation.
Article
When your program's compilation broke with a brand-new C++20 feature, you often end with a few questions: Did I something wrong? Did I found a compiler bug? Does my compiler not yet support this feature? Thanks to the feature testing in C++20, the last question is easy to answer.
Article
When you compare signed and unsigned integers, you may not get the result you expect. Thanks to the six std::cmp_* functions, there is a cure in C++20.
Article
On his blog Modern C++ he deals intensively with his passion C++.
Library
shared libraries for terminal handling
Library
A library for text mode user interfaces
Library
A text-based widget toolkit