gansm

The extended chrono library makes it relatively easy to ask for the time duration between calendar dates.

I created calendar dates in my last post, “C++20: Creating Calendar Dates,” and I will display and check them today.

In this post, I will dive deeper into calendar dates and create them.

This new data type std::chrono::hh_mm_ss in C++20 stands for the time of day.

Today, I continue my journey through the basic types with time durations and time points.

To get the most out of the chrono extension in C++20, a basic understanding of the chrono terminology is essential.

Implementing a formatter for a user-defined type having more than one value in C++20 is challenging.

Additionally, to the basic types and std::string, you can also format user-defined types in C++20.

In my last post, “The Formatting Library in C++20: The Format String“, I presented a few of the format specifications of the format string. Today, I finish my job.

I introduced “The Formatting Library in C++20” in my last post. Today, I will dive deeper into the format specification of the format string.

Today, I will start a series about the formatting library in C++20. The series is based on my C++20 book.

A std::span represents an object that refers to a contiguous sequence of objects. Today, I want to write about its not-so-obvious features.

You can define the three-way comparison operator or request it from the compiler with =default. But do you know that you can also define or request the equality operator in C++20?

I’m happy to present in this guest post by Ljubic Damir a typical use-case for coroutines: a producer – consumer workflow.

In my last two posts, I presented priority schedulers for coroutines. The schedulers had a bug.

Today, I use the straightforward scheduler from the post “A Priority Scheduler for Coroutines” and improve its priority handling

In this post, I will extend the straightforward scheduler from Dian-Lun with priorities.

The last post “A Concise Introduction to Coroutines by Dian-Lun Li” provide the theory. Today, Dian-Lun presents his single-threaded scheduler for C++ coroutines. This post assumes you are familiar with the previous post “A Concise Introduction to Coroutines by Dian-Lun Li“.

Today, I will start a miniseries about a scheduler for tasks. The starting point of this miniseries is a straightforward scheduler by Dian-Lun Li that becomes increasingly sophisticated.

The ranges library in C++20 made due to performance reasons a few unique design choices. These choices have consequences: cache issues and constness issues.

Thanks to the ranges library, working with the Standard Template Library (STL) is much more comfortable and powerful. First of all, the algorithms of the ranges library are lazy, can work directly on the container, and can be composed. Additionally, the ranges library made a few unique design choices, you must know.

In my last post, “C++20: Module Support of the Big Three“, I compiled a simple module with the Big Three. Today, I drill deeper using the GCC, Clang, and Microsoft Compiler.

I have written almost 100 posts about C++20 in the last four years, but I’m not done. This post continues my story about C++20.

Thanks to polymorphic allocators in C++17, you can optimize your memory allocation. This optimization includes performance and the reuse of memory.

I introduced in my last post “Polymorphic Allocators with C++17” the theory of polymorphic allocators in C++17. Today, I will apply the theory.

This post starts a miniseries about an almost unknown feature in C++17: polymorphic allocators. I often promised that I would write about polymorphic allocators. Today, I fulfill my promise.

C++20 does not provide concrete coroutines, but C++20 provides a framework for implementing coroutines. This changes with C++23. std::generator is the first concrete coroutine.

A std::mdspan is a non-owning multidimensional view of a contiguous sequence of objects. The contiguous sequence of objects can be a plain C-array, a pointer with a size, a std::array, a std::vector, or a std::string.

he four associative containers std::flat_map, std::flat_multimap, std::flat_set, and std::flat_multiset in C++23 are a drop-in replacement for the ordered associative containers std::map, std::multimap, std::set, and std::multiset. We have them for two reasons in C++23: memory consumption and performance.

C++23 extends the interface of std::optional and gets the new data type std::expected for error handling.