C++: News Until C++20 (2025-05-14 - 2050-05-15)¶

Day 1 ¶

Lambda ¶

There was some controversy among the audience about the usage of lambda in their code, so I tried to demystify it right at the beginning.

Concepts (a.k.a. “Template error messages are a PITA”)¶

Definitely new in C++20, concepts are there to bring better C++ template error messages to the world.

`constexpr`, and the C++20 `consteval` and `constinit`¶

C++20 has a ton of new keywords, all building upon the constexpr capability of modern C++.

The Spaceship Operator ¶

Created to bring some order to the ordering operators <, >, <=, >=, ==, !=, the spaceship operator brings disorder at first sight (P1185R2).

The Spaceship Operator <=> (And Comparison In General)

Day 2 ¶

The bigger part of the second day was dedicated to multithreading. This is good thing because there’s a lot to be said and known.

The remaining time was used to somehow shutdown the course looking over less relevant topics in a frontal way.

Multithreading (And Related Topics)¶

Atomic Shared Pointer (std::atomic<std::shared_ptr<>).
- Discussed why a “normal” shared pointer is only half threadsafe
- How to use it safely pre 20, to get to the solution - atomic shared pointer.
- On a sideway, we saw how to use promise and future for one-shot synchronization (here)
The C++ Memory Model
- Discussed load-modify-store, and non-atomicity in general.
- Memory orders “acquire” and “release”. A naive spinlock implementation to demonstrate what a mutex is.
- Memory order “sequential consistency” (and its application to the load-modify-storeproblem).
Threads in C++
std::mutex And Friends
Scoped Locking

Not strictly C++20 news, we quickly ran over these.

Something Different: Coroutines ¶

Another form of parallelism. To get hold of it, a showed (in Python) what generators are, and what asyncio is. The message: both are applications of coroutines.

Generator

Async

fibonacci.py¶

def fibonacci():
    first, second = 1, 1
    yield first
    yield second
    while True:
        third = first + second
        yield third
        first, second = second, third

for num in fibonacci():
    print(num)

asio.py¶

import asyncio

async def one_loop():
    while True:
        await asyncio.sleep(1)
        print('hallo one_loop')

async def another_loop():
    while True:
        await asyncio.sleep(1.1)
        print('hallo another_loop')

async def main():
    async with asyncio.TaskGroup() as tg:
        tg.create_task(one_loop())
        tg.create_task(another_loop())

asyncio.run(main())