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...

Behind Enemy Lines - Reverse Engineering C++ in Modern Ages

by Gal Zaban

What do C++ programs really look like? When developers think about hierarchy and virtual calls they see it as design patterns and code but reverse engineers look at it from a different angle, they think about Assembly puzzles.

C++ is known as a tangled language, templates, lambdas and pointers. All of these features create a jungle of objects intended to make life easier for the programmer. But once the program is compiled, the target program is no longer what it once seemed.

Reversing C++ programs is tedious, demanding, and requires rebuilding inheritance, identifying templates and tainting program flow in order to combat the ties of function overloading and class utilization.

C++ Binaries are a world of mysteries. In my presentation I am going to show how C++ binaries looks like after compilation and how reverse engineers see C++ binaries and understand their logic...

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.

Building a Coroutine based Job System without Standard Library

by Tanki Zhang

A job system is a common game engine component to improve total CPU throughput. In this talk, I will walk through building a coroutine-based job system and explain the advantages of using coroutines over the typical ways to build a job system.

We shipped coroutines in C++20, but why does it matter for users, especially since there’s no standard library support? The answer is the coroutine semantics. Developers can customize the behavior of `co_return`, `co_yield`, `co_await` to build their own systems without any dependency of the standard library. For game developers, this is important because many game studios forbid the use of the standard library. The coroutine language feature itself is flexible enough to build a system with 100% control, which is exactly what engine developers want—no black box, no magic.

I will discuss the design decision I made, trade-offs, and current limitations. This talk is a crash course for system developers who want to build systems independently from the standard library and will also discuss possible future directions for this language feature.

This is an advanced coroutine talk and I expect attendees to have basic understanding about how (c++)coroutine works. Here is a useful link for some related materials if you want more information before attending this talk: https://gist.github.com/MattPD/9b55db...

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...

Highlighting the Student and Support tickets for Meeting C++ 2021

by Jens Weller

With the talk listing published, and the schedule coming soon, I'd like to highlight the student and support tickets for Meeting C++ 2021.

For a few years now Meeting C++ has hosted programs to give students, underrepresented folks and those who can't afford a ticket access to the conference. This is supported through the ticket sales and some times sponsorships...

Compiled C++ Coding Standards

by Valentin Galea

Coding conventions, guidelines and standards are a perennial effort of software development. Lots of work goes into preparing and writing them but arguably less in following them - partly because these are documents usually maintained outside of main development, so they evolve separately and often retroactively.

We will show a novel model whereby the coding standard chosen by a team is a 'live' source code file integrated into a production repository so that it participates in compilation. This immediately brings a couple of advantages that we will explore in detail, as well as the implications it has in the context of a full team of developers.

As a practical example, the coding standard files of Splash Damage - a game development company - will be shown and discussed, detailing the various C++ aspects they deal with it and the techniques encouraged therein. Going further than the code, we'll talk about the human factor and how standards are written, evolved and championed across a large company in the face of different constraints between projects and teams.