C++20 Coroutines — Complete* Guide

by Šimon Tóth

C++20 brought us initial support for coroutines. In this article, we will go over several examples of coroutines that build upon each other. Word of warning, though, the support in C++20 is mainly targeted at library implementors. C++23 should be bringing additional support that should cover at least the most common use cases...

C++20 Coroutine Iterators

by Martin Bond

In my first blog post about C++20 Coroutines I introduced the concepts behind a synchronous or generator style coroutine and developed a template class to support coroutines for any data type.

In this post I’ll add an iterator to the template to support the range-for loop and iterative algorithms. You may want to review that post before reading this one but the following code should act as a reminder about how to write and use a coroutine to read two floating point values into a data structure for subsequent analysis...

Smart Tricks with Parameter Packs and Fold Expressions

by Rainer Grimm

To complete my post about variadic templates and fold expressions, I present in this post smart tricks using parameter packs and fold expressions...

Concepts — case studies

by Andrzej Krzemieński

This post has been inspired by the readers’ questions about using concepts to solve real problems. We will have a look at two such problems and see if, and how, concepts can help...

Find your dream C++ job next week!

by Jens Weller

The 3rd edition of the Meeting C++ online job fair is next week on September 28th & 29th!

Each of the events lasts 3 hours in which you can hop from table to table to meet with different employers! Right now you are able to already submit your application via the CV/resume sharing form with the 3 companies sponsoring the event. The event will be hosted for the first time on Hubilo, which features a lounge as the main event part. On Tuesday the event in in the European Afternoon, which is also great for folks from Asia/Oceania to join, while the event on wednesday evening (CEST) is easier to join for folks from the Americas and Europe/Africa.

C++20 Coroutines

by Martin Bond

There seems to be a lot of confusion around the implementation of C++20 coroutines, which I think is due to the draft technical specification for C++20 stating that coroutines are a work in progress so we can’t expect full compiler and library support at this point in time.

A lot of the problems probably arise from the lack of official documentation about working with coroutines. We have been given C++ syntax support for coroutines (the co_yield and co_return) but without all of what I consider full library support. The standard library has hooks and basic functionality for supporting coroutines, but we must incorporate this into our own classes. I anticipate that there will be full library support for generator style coroutines in C++23.

The C++20 specification is obviously looking to provide support for parallel (or asynchronous) coroutines using co_await, which makes the implementation of a simpler generator style synchronous coroutines more complex. The implementation requirements for our coroutines utilises a Future and Promise mechanism similar to the std::async mechanism for asynchronous threads.

If you are a Python or C# developer expecting a simple coroutine mechanism, you’ll be disappointed because the C++20 general purpose framework is incomplete. Having said that, there are many blogs and articles on the web that include a template class that supports generator style coroutines. This blog contains a usable coroutine template and example code after discussing what a coroutine is...

C++20 Concepts — Complete Guide

by Šimon Tóth

One of the well deserved common complaints about C++ is the low quality of compiler errors. Both GCC and Clang made a lot of progress to improve the situation in the past 10 years, but templated code is one area where they can’t really help...

From Variadic Templates to Fold Expressions

by Rainer Grimm

In my last two posts "Variadic Templates or the Power of Three Dots" and "More about Variadic Templates", I introduced variadic templates. This post goes one step further in the future and presents fold expressions that can directly reduce a parameter pack with a binary operator...

Design Patterns VS Design Principles: Iterator, Mediator and Memento

by Jonathan Boccara

In our objective to understand how the GoF design patterns relate to the GRASP design principles, we’re going to analyse 3 more Behavioural patterns today: Iterator, Mediator and Memento...

Coercing deep const-ness

by Barry Revzin

In C++, template deduction doesn’t allow for any conversion. A type matches the pattern, or it’s a deduction failure. But there’s one sort-of exception to this rule, and it’s an exception that everyone has taken advantage of...