When your module becomes bigger you want to divide its functionality into manageable components. C++20 modules offer two approaches: submodules and partitions. Let me discuss both approaches in this post.

Thanks to the module interface unit and the module implementation unit, you can separate the interface from the implementation when defining a module. Let me show, how.

Modules are one of the four prominent features of C++20. They overcome the restrictions of header files and promise a lot: faster build-times, fewer violations of the One-Definition-Rule, less usage of the preprocessor. Today, I want to create a simple math module.

I'm happy to announce that I offer English and German online seminars.

Modules are one of the four big features of C++20: concepts, ranges, coroutines, and modules. Modules promise a lot: compile-time improvement, isolation of macros, the abolition of header files, and ugly workarounds.

This post is the third and final post in my miniseries to cppcoro. cppcoro is a library of coroutine abstractions from Lewis Baker. Today, I introduce thread pools.

I gave in my last post "C++20: Coroutines with cppcoro", a basic introduction to the coroutines library from Lewis Baker. This introduction covered the elementary coroutines task and generator. Today, I add threads to tasks and get powerful abstractions. 

The cppcoro library from Lewis Baker gives you what C++20 doesn't give you: a library of C++ coroutine abstractions based on the coroutines TS.

It's a typical requirement for thread management to synchronize them. One thread prepares, in this case, a work-package another thread is waiting for. 

educative.io gave me four vouchers for which they will give a learner 3-month access to all Educative courses.