Marc Gregoire’s Blog

I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Wednesday May 13th, 2026 at 18:00 at Nokia.

Nokia ( https://www.nokia.com/ ) is sponsoring this event by providing the location, drinks and catering.

The agenda is as follows:

• 18:00: Reception with food.
• 18:30: Session 1: Designing Data for Performance and Maintainability (Laurent Carlier)
  Modern software performance often depends less on algorithms and more on how data is organized in memory. This talk explores why optimizing data layout is critical for achieving high performance, particularly in systems programming and data-intensive applications.
  We begin by examining the importance of cache-friendly data structures. While they can have significantly boost performance, they also introduces practical challenges.
  The talk then presents a structured solution to address these drawbacks, restoring usability while preserving performance benefits.
  Finally, we explore how modern reflection techniques can be leveraged to eliminate code repetition, enabling cleaner, safer, and more maintainable code without sacrificing efficiency.
  Attendees will gain practical insights into balancing performance and code quality, along with techniques that can be applied to real-world systems.
• 19:30: Break
• 19:45: Session 2: The fastest Java Virtual Machine is the C++26 compiler (Koen Samyn)
  Static compile time reflection is a capability that for a long time seemed like an impossibility for C++. Over the years however, the compiler itself gained the capability of executing C++ code while compiling, which opened the door to adding this meta capability to the language.
  The contents of the talk follows a logical progression: the basics of reflection, writing a simple serializer. The talk concludes with an example of std::meta::substitute (a hidden gem in the P2996 proposal) which is used to transform a java bytecode program into an executable C++ program.
• 20:45: Introduction to Nokia, followed by a drink.

We will be giving away two copies of Professional C++, 6th Edition.

The event is free for everyone, but you need to register for it.

There are 80 seats available for this event.

Note: The deadline for registrations is May 10th, 2026!

🚀 Exciting News: Announcing the First-Ever BeCPP Symposium!

The BeCPP organization is proud to invite the community to a full day of Modern C++ at Howest, Campus Kortrijk on Monday, March 30, 2026.

We are kicking things off with a stellar lineup of international speakers:

• Bryce Adelstein Lelbach — The CUDA C++ Developer’s Toolbox
• Chris Croft-White — Agentic Time-Travel Debugging
• Guy Davidson — Abstraction: The True Superpower of C++
• Andre Kostur — There’s a Hole in the C++ Type System
• Phil Nash — Contemporary C++ Testing
• Keith Stockdale — The journey to “/W4 /WX”: How hard could it be?
• Herb Sutter — C++: Growing in a world of competition, safety, and AI

➕ Couple more speakers to be revealed soon!

Event Snapshot:

• 📅 Date: March 30, 2026 (Doors open 09:00)
• 📍 Location: The Penta, Kortrijk
• 🎟️ Capacity: Limited to 300 seats
• 💶 Price: €30 + VAT/BTW

A special thank you to our sponsors for making this possible:

• Silver🥈 think-cell Software
• Bronze🥉 HOWEST Hogeschool West-Vlaanderen / JetBrains / Nikon Metrology
• Community: CppCon, The C++ Conference / ACCU On Sea

⚠️ Registration Deadline: March 23, 2026. Don’t miss out!

👉 Secure your seat here: https://becpp.org/Symposium2026/

Visual Studio 2026 (version 18.0) is now generally available! It includes a lot of new features, bug fixes, and performance improvements across the board. Here is a selection of what’s new for C++ developers, including new features and improvements:

• A refreshed IDE UI
• Support for Visual Studio 2022 extensions out of the box
• Seamless upgrade experience from an older version of Visual Studio
• Microsoft C++ (MSVC) Build Tools v14.50: Greater C++23 conformance and runtime performance improvements
• AddressSanitizer support for ARM64 targets (Preview)
• IDE productivity improvements:
  • New keyboard shortcuts
  • Syntax highlighting for C++ attributes
  • Class View substring searches and performance improvements
  • Generate preprocessed output
  • Enhanced controls in the bottom margin, including viewing and setting file encoding
  • File exclusion options in Quick Find and Find in Files
• GitHub Copilot Chat: improved chat experience and new context menu options
• C++ project system changes (MSBuild and CMake)
• New clang-tidy configuration options
• Set command line arguments for the debugger from the toolbar
• Mermaid chart rendering
• Podman support in Container Tools
• Git tools improvements

This blog post by Microsoft gives details on all of the above.

You can also read the broader announcement on the Visual Studio Blog for more details on changes that are non-C++-specific.

I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Tuesday December 2nd, 2025 at 18:00 at Digital Arts and Entertainment powered by Howest (Campus “The Level”).

Digital Arts and Entertainment powered by Howest ( https://digitalartsandentertainment.be/ ) is sponsoring this event by providing the location, drinks and catering.

The agenda is as follows:

• 18:00: Reception with food.
• 18:30: Session 1: Fifteen Years of Modern C++: My Favorite Features So Far (Tom Tesch)
  C++ keeps evolving — from the subtle conveniences of C++14 to the expressive power of the upcoming standards.
  In this talk, I’ll share a personal best-of: the language and library features I actually use, love, or teach — with small live examples of how they make code clearer, safer, or just more fun to write.
  This isn’t a standard-by-standard checklist, but a practical reflection on what the past decade of evolution has meant for everyday C++ developers.
• 19:30: Break
• 19:45: Session 2: Distributed programming with coroutines and asynchronous communication frameworks (Johan Vanslembrouck)
  This presentation will demonstrate how asynchronous communication frameworks, such as Boost ASIO, Qt, gRPC, Windows overlapped IO, ROS2, TAO and proprietary frameworks, can be used with a single coroutine library to write responsive, distributed applications using a uniform synchronous programming style. Applications that use coroutines are easier to write and are more readable, maintainable and extensible than applications not using coroutines.
  No changes are necessary to these frameworks to use them with the library, and no changes are necessary to the coroutine library to use it with a new communication framework. The presentation will compare examples written with a subset of these frameworks, more in particular, Boost ASIO, Qt, gRPC and Windows overlapped I/O (based upon cppcoro). For each framework, I will compare an example that does not use coroutines with an example that uses coroutines, and (if supported by the framework) with an example that uses synchronous calls.
  The source code of all examples is available on GitHub and runs on Windows 10/11 and on Ubuntu 22.04/24.04 (apart from Windows overlapped I/O) or similar.
• 20:45: Introduction to Digital Arts and Entertainment powered by Howest, followed by a drink.

We will be giving away two copies of Professional C++, 6th Edition.

We will also be giving away one physical copy and two e-books of C++ Memory Management: Write leaner and safer C++ code using proven memory-management techniques.

The event is free for everyone, but you need to register for it.

There are 150 seats available for this event.

Note: The deadline for registrations is November 28th, 2025!

I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Tuesday April 22nd, 2025 at 18:00 at KLA.

KLA ( https://www.kla.com/ ) is sponsoring this event by providing the location, drinks and catering.

The agenda is as follows:

• 18:00: Reception with food.
• 18:30: Session 1: Algorithm intuition revisited (Bruno Hendrickx)
  In this talk, we delve into the concept of “algorithm intuition,” a term coined by Conor Hoekstra, inspired by Sean Parent’s influential “C++ Seasoning” presentation. While data structure intuition is a natural development for most software developers, algorithm intuition often requires more deliberate work.
  This presentation aims to revisit and expand upon Hoekstra’s insights, exploring how a deeper understanding of standard algorithms can help to ease problem solving in modern C++.
  We will examine key algorithms from the Standard Template Library (STL), demonstrating their practical applications and how they can be leveraged to write more efficient, readable, and maintainable code.
• 19:30: Break
• 19:45: Session 2: Compile-Time Emulation of an 8080-Inspired System in C++ (Tom Tesch)
  Emulating an 8080-like system is a great exercise in low-level programming—but what if we could optimize it at compile time? This talk starts with a simple interpreter and then refines it using modern C++ techniques like constexpr and std::array, shifting work to the compiler to reduce runtime overhead and improve performance.
• 20:45: Introduction to KLA, followed by a drink.

We will be giving away two copies of Professional C++, 6th Edition.

The event is free for everyone, but you need to register for it.

There are 75 seats available for this event.

Note: The deadline for registrations is April 20th, 2025!

I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Wednesday January 15th, 2025 at 18:00 at Siemens.

Siemens ( https://plm.sw.siemens.com/en-US/simcenter/physical-testing/testlab/ ) is sponsoring this event by providing the location, drinks and catering.

• 18:00: Reception with food.
• 18:30: Session 1: Several easy ways to increase the quality of your code, make them yours (Lieven de Cock)
  There are many easy-to-use tools, that help us improve the quality of our code. Nevertheless, there seem to be developers who are not familiar with those tools or don’t use them.
  Why ?
  If the machine can have our back, with quick feedback loops, we should take advantage of that.
  The compiler is your best friend, tweak the warning levels up. Or should we say: compilers are your best friends.
  The next step is static analyzers, once again have the machine inspect your code, no personal preferences to discuss in code reviews, the machine won’t budge or become emotional. We will look at cppcheck and clang-tidy.
  Also at run time we have a few friends to help us out, the sanitizers do an excellent job at finding issues, we will look at valgrind, UBSAN, ASAN, TSAN.
  There are many ways to use these tools, we will look at a way, but there are other ways, find your way in case you don’t like the presented way, as long as you start using the tools.
  We will also look at a way to integrate these tools into the cmake/ctest eco-system.
• 19:30: Break
• 19:45: Session 2: Why use coroutines for asynchronous applications? (Johan Vanslembrouck)
  “The Coroutines TS provided a wonderful way to write asynchronous code as if you were writing synchronous code. You just need to sprinkle co_await at appropriate points and the compiler takes care of suspending the coroutine, preserving state across suspend-points and resuming execution of the coroutine later when the operation completes.” (https://lewissbaker.github.io/2020/05/11/understanding_symmetric_transfer)
  An application developer no longer must cut an application into small pieces that do not wait/block internally and that must be stitched together, e.g. using a chain of callback functions or state machines. The C++20 compiler does all the hard work for you now, even for functions with a complex control flow. As a result, you can develop applications much faster, and they are more maintainable than without the use of coroutines.
  The presentation will discuss several example programs, comparing a synchronous version with an asynchronous version and a coroutine version. By the end of presentation, I hope you will be convinced that coroutines are a valuable addition to C++ to write responsive, asynchronous applications.
  The presentation includes a short introduction to coroutines; no in-depth a priori knowledge of coroutines is necessary to follow the presentation.
• 20:45: Introduction to Siemens, followed by a drink.

We will be giving away two copies of Professional C++, 6th Edition.

We will also give away two copies of Beginning C++23, From Beginner to Pro.

The event is free for everyone, but you need to register for it.

There are 50 seats available for this event.

Note: The deadline for registrations is January 12th, 2025!

I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Tuesday October 8th, 2024 at 18:00 at Dekimo.^*

Dekimo ( https://www.dekimo.com/ ) is sponsoring this event by providing the location, drinks and catering.

• 18:00: Reception with food.
• 18:30: Session 1: Better Threading in C++20 (Lieven de Cock)
  We got threading support by the language and library in C++11. There were however a few things missing, like RAII for a thread object, or a nice way to stop a thread, or to request it to stop. Similar problem, how do we stop a ‘waiting’ condition variable. Most developers have solved these problems with home made solutions. C++20 brings standardized solutions to the table.
  Next to that we also get some new synchronization facilities like barrier/latch/semaphore, all nice additions. There is no longer a need to re-invent the wheel or reach out to 3rd-party libraries. We will look at all these new little tools and investigate on how to use them. So register your stop callback, and by the end of the talk we will request our source to stop, and in our ‘cooperative cancellation’ scheme, do not forget to keep an eye on your stop token.
• 19:30: Break
• 19:45: Session 2: Fibers: CoRoutines from the OS (Dave De Breuck)
  This talk delves into fibers in C++, focusing on their role in enhancing concurrency and efficiency. Fibers use cooperative context switching, making them ideal for high-concurrency applications. We’ll explore the principles of fibers, their advantages over traditional threads, and their implementation in C++.
• 20:45: Introduction to Dekimo, followed by a drink.

We will be giving away two copies of Professional C++, 6th Edition.

We will also give away two copies of Beginning C++23, From Beginner to Pro.

The event is free for everyone, but you need to register for it.

There are 75 seats available for this event.

Note: The deadline for registrations is October 1st, 2024!

^* There are limited number of parking places available at the location itself. However, there are free parking places available on the Brusselsesteenweg and in the streets around the office. Additionally, the free P+R parking Gentbrugge Arsenaal is at 1km with a tram connection to the office. There is a bus stop and a tram stop in front of the office.

Pure Virtual C++ is a free one-day virtual conference for the whole C++ community. This year it will run on April 30th 15:00 UTC. Sign-up for free to get access to five sessions on the day and a host of pre-conference content.

Here is the list of sessions:

• Automated Testing of Shader Code with Keith Stockdale (Rare) – Rare has a rich culture of writing automated tests for their game and engine code. The ‘Sea of Thieves’ project has hundreds of thousands of automated tests that exist to validate behavior and to ensure that bugs are kept to a minimum, as we continually deliver an ever-changing experience to players. Among this large test suite are tests that validate and verify shader code. This session explores the new Rare Shader Test framework, describing how tests are written for shader code. The talk will also delve into the C++ and HLSL implementation of the shader testing framework to discuss the design goals of the system, and how we are using C++ to meet these design goals.
• Message Handling with Boolean Implication with Ben Deane (Intel) – Message reception and dispatch is something common to many codebases. This talk shows the unreasonable effectiveness of going back to basics and really understanding and unlocking the power of Boolean algebra in the design of a message handling library. We’ll talk about composing predicates on messages and manipulating them at compile time in order to do the least work when dispatching them at runtime. Particularly we’ll introduce implication, develop an intuition for this lesser-used Boolean operation, and see how it is key to a generic approach for simplifying predicates.
• I Embedded a Programming Language In Debug Information with Sy Brand (Microsoft) – DWARF information on Linux provides debuggers with a bridge between high-level source code and the machine instructions generated by the compiler. As part of this, it describes how to locate variables within your program at runtime using a language called DWARF Expressions. When implementing a parser for DWARF Expressions I thought “this seems suspiciously Turing-complete, can I implement a programming language inside this?” It turns out the answer is yes. In this session you’ll learn how debug information and executables are stored on Linux systems and how I managed to (ab)use them to implement a programming language interpreter that runs when you ask your debugger for the address of a variable.
• Enhancing C++ development with Copilot Chat with Sinem Akinci (Microsoft) – Copilot is an AI-powered pair programmer integrated into Visual Studio and VS Code that can be there to assist you at many different points in your C++ development journey. In this session, we’ll introduce Copilot and Copilot Chat, share tips for achieving the results you want, and provide different use cases for using these tools. Then, we’ll see these tools in action in C++ code in Visual Studio as we tackle a variety of problems from navigating and understanding code to refactoring existing code.
• Progress Report: Adopting Header Units in Microsoft Word with Zachary Henkel (Microsoft) – Microsoft Office is a huge C++ codebase with nearly 100 million lines of native code. This size provides a constant challenge to build the product as quickly as possible. C++20 header units are a way to receive many of the benefits of modules, while still working with a codebase originally designed for classic header inclusion. At CppCon 2022 we announced that Office would investigate header units with the goal of improved build throughput. We’re excited to present the results of that work for the benefit of the C++ community at large. In this session, we’ll share build performance metrics for the first time.

I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Monday April 8th, 2024 at 18:00 at Attentia.

Attentia ( https://www.attentia.be/ ) is sponsoring this event by providing the location, drinks and catering.

The agenda is as follows:

• 18:00: Reception with food.
• 18:30: Session 1: Building a class for modular arithmetic (Toon Baeyens)
  Writing modern C++ is not easy. Yet, doing it well brings you many benefits. The code will be elegant, and the program will be fast.
  In this talk, we will be building a type for modular arithmetic as an excuse to discover many powerful features and techniques within the C++ ecosystem.
  This adventure will take us from concepts, metaprogramming, and dependent types to integer division, studying generated assembly and micro-benchmarking.
• 19:30: Break
• 19:45: Session 2: Using C++ in the cloud using the AWS C++SDK (Hans Klabbers)
  Have you ever wondered what cloud computing and serverless provide you as a software developer that creates software with C++? During this talk you will get insight in Amazon Web Services a.k.a. AWS Cloud. A demo of a serverless solution created with AWS services and software built with C++ will be shown during the talk.
• 20:45: Introduction to Attentia, followed by a drink.

We will be giving away a copy of Professional C++, 6th Edition.

We will also give away a copy of Beginning C++23, From Beginner to Pro.

The event is free for everyone, but you need to register for it.

There are 60 seats available for this event.

Note: The deadline for registrations is April 4th, 2024!

I’m proud to announce that the new edition of my book “Professional C++, 6th Edition” is finished 🙂
It has been updated to the C++23 standard and uses certain C++23 features throughout all examples.

It is published by Wiley/Wrox, and available on Amazon.

Official Description

Expand your C++ knowledge quickly and efficiently with this advanced resource

In the newly revised sixth edition of Professional C++, veteran software engineer and developer Marc Gregoire delivers yet another volume that raises the bar for advanced programming manuals. Covering almost all features of the new C++ standard codenamed C++23, the book offers case studies with working code that’s been tested on Windows and Linux.

As the leading resource for dedicated and knowledgeable professionals seeking to advance their C++ skills, this book provides resources that help readers:

• Master new features of the latest standard, C++23
• Maximize C++ capabilities with effective design solutions
• Discover little-known elements and learn about pitfalls and what practices to avoid
• Grasp testing and debugging best practices
• Learn about tips and tricks for efficiency and performance

C++ is a complex language. Professional C++, 6th Edition, allows dedicated practitioners to remain current and abreast of the latest developments and advances.

This year at CppCon 2023, I gave the following session:

• “C++23 An Overview of Almost All New and Updated Features”

You can find the slides of the session below.

I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Tuesday October 31st, 2023 at 18:00 at DAE and Howest (Howest, Campus Kortrijk Weide – The Penta).

DAE ( https://digitalartsandentertainment.be/ ) and Howest ( https://www.howest.be/ ) are sponsoring this event by providing the location, drinks and catering.

 

The agenda is as follows:

• 18:00: Reception with food.
• 18:30: Session 1: Elevating Precision in C++: A Journey below the Surface of Floating-Point (Tom Tesch)
  Floating-point numbers, with their varying levels of precision, serve as foundational components in the toolkit of both new and seasoned C++ developers. In this presentation, we will uncover the inner workings of floating-point variables, explore their limitations, and discuss strategies for extending precision while being mindful of associated trade-offs. Join us as we embark on a journey into the realm of floating-point arithmetic in C++, offering insights that will enhance your programming finesse.
• 19:30: Break
• 19:45: Session 2: Coroutines: Don’t try this at home (Lieven de Cock)
  In C++20 we got the core language feature “coroutines”. Mostly oriented to the advanced c++ programmers, and not for the mere mortals, since it requires a lot of boilerplate one would not like to write. It provides the fundamentals to further build upon. Unfortunately the STL library did not build on it yet, more was to come in C++23.
  In C++23 we will only get one follow up: std::generator.
  So let’s revisit coroutines. What are they? A function that can be suspended and resumed. Easily said, but how to make use of it and write that boilerplate after all. We will look at the coroutine from 2 different angles: the user code and the compiler, and we will inspect what each wants or would like to have, and where we need to glue them together and what is needed for that purpose. We will give insights on topics like: coroutine frame, couroutine handle, promise_type, the interface or api.
  And if time permits we will look at an example of coroutines in use in asynchronous code (because a misconception is that coroutines (purely) have to do with threads and async’s).
• 20:45: Introduction to DAE and Howest, followed by a drink.

The event is free for everyone, but you need to register for it.

There are 250 seats available for this event.

Note: The deadline for registrations is October 29th, 2023!

I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Thursday May 11th, 2023 at 18:00 at Twikit.

Twikit ( https://www.twikit.com/ ) is sponsoring this event by providing the location, drinks and catering.

The agenda is as follows:

• 18:00: Reception with food.
• 18:30: Session 1: C++23 – What’s in it for You? (Marc Gregoire)
  C++23, the next release of the C++ standard, introduces new features to the core language and to the Standard Library. This session will bring you up to date with the latest features coming with this new release.
  The session includes core language topics such as consteval if statements, multidimensional subscript operators, decay copy, unreachable code, and more. New Standard Library features that will be shown include monadic operations for std::optional, std::flat_map, std::flat_set, a stacktrace library, changes to the ranges library, improvements to std::format, std::expected, and many more.
• 19:30: Break
• 19:45: Session 2: Emscripten, what and how? (Dave De Breuck)
  This talk will give a brief introduction of Emscripten itself and explain how Emscripten, an LLVM-based compiler, converts C++ to JavaScript, which lets you run a C++ codebase on the web at near-native speed.
• 20:45: Introduction to Twikit, followed by a drink.

The event is free for everyone, but you need to register for it.

There are 60 seats available for this event.

Note: The deadline for registrations is May 9th, 2023!

When you have a class representing multidimensional data, providing access to a specific element in this multidimensional space is often done by providing an operator() with as many parameters as there are dimensions. You had to resort to operator(), because operator[] only supported a single index.

That’s now history, as C++23 introduces the multidimensional subscript operator. Providing such an operator for your class is straightforward:

import std;

template <typename T>
class Matrix
{
public:
	Matrix(std::size_t rows, std::size_t cols)
		: m_rows{ rows }, m_cols{ cols }
	{
		m_data.resize(rows * cols);
	}

	T& operator[](std::size_t x, std::size_t y) { return m_data[x + y * m_cols]; }

private:
	std::size_t m_rows;
	std::size_t m_cols;
	std::vector<T> m_data;
};

The class can be tested as follows:

const std::size_t Rows{4};
const std::size_t Cols{4};
Matrix<int> m{ Rows, Cols };
std::size_t counter{ 0 };
for (std::size_t y{ 0 }; y < Rows; ++y)
{
	for (std::size_t x{ 0 }; x < Cols; ++x)
	{
		m[x, y] = ++counter;
	}
}

for (std::size_t y{ 0 }; y < Rows; ++y)
{
	for (std::size_t x{ 0 }; x < Cols; ++x)
	{
		std::print("{} ", m[x, y]);
	}
	std::println("");
}

Whenever you learn a new programming language, the first program you write is often a “Hello World!” program that simply prints out “Hello World!” to the console. Up to now, for C++, this usually was something along the following lines:

#include <iostream>

int main()
{
    std::cout << "Hello World!" << std::endl;
}

This code snippets imports the required header, <iostream>, and uses std::cout to output text to the standard console.

With modern C++23, this simple program looks quite a bit different:

import std;

int main()
{
    std::println("Hello World!");
}

What has changed?

• Instead of including the exact headers that are required, you simply import a single named module, std, provided by the standard.
• Instead of using std::cout, stream insertion operators, and std::endl, you simply use std::println().

Unfortunately, at the time of this writing, there are no compilers yet supporting all the above new features, but soon there will be.

For the time being, if your compiler doesn’t support the named module std yet, you can simulate it yourself by writing your own named module called std. You can do this by writing a code file called std.cppm with the following contents:

export module std;

export import <iostream>;

You can extent this std.cppm named module with whatever header you need in your program.

Secondly, if your compiler does not support std::println() yet, you can simulate it with your own print module in a print.cppm file, e.g.:

export module print;

import <string_view>;
import <iostream>;
import <format>;

namespace std
{
    export template <typename... Args>
    void println(std::string_view sv, Args&&... args)
    {
        std::cout << std::vformat(sv, std::make_format_args(args...)) << std::endl;
    }
}

Warning: this is a very basic simulation of std::println(), which does not support all the features of the real std::println()!.

I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Tuesday January 17th, 2023 at 18:00 at Medicim / Envista.

Medicim / Envista ( https://www2.medicim.com/ ) is sponsoring this event by providing the location, drinks and catering.

The agenda is as follows:

• 18:00: Reception with food.
• 18:30: Session 1: Constraints and Concepts (Peter Van Weert)
  This presentation consists of two parts:
  First, I explain how you can, and more importantly should, constrain your template arguments using requires clauses and, typically, concepts. Doing so results in more readable compilation errors, self-documenting template definitions, and easier, more expressive template specialization.
  Next, I show how you can define your own concepts using the new syntax introduced in C++20. Quite some new syntax to learn, for sure, but you’ll quickly see that constraints and concepts are far easier to master (or at least understand) than the more advanced SFINAE techniques (std::enable_if_t, std::void_t, …) they essentially supersede.
• 19:30: Break
• 19:45: Session 2: Space Invaders: The Spaceship Operator is upon us (Lieven de Cock)
  Before C++20 we had to write 6 comparison operators for our user defined types (or even more). For sure, a tedious task. All this gets simplified with the introduction of the spaceship operator.
  What happens to your code, when you turn on “-std=c++20” even before we go near the spaceship operator, did your build break? Why does that happen? We will first investigate, another new feature of C++20, the rewriting rules, and how that impacts your code base. And then we will dissect the spaceship operator, from a using perspective, and from an implementation perspective. Oh yes, comparison categories, what are those, and why are these important with respect to the spaceship operator? All will be answered, what initially looked so simple, does require some extra thoughts it seems to correctly use the tool.
• 20:45: Introduction to Medicim / Envista, followed by a drink.

We will be giving away a copy of Professional C++, 5th Edition.

The event is free for everyone, but you need to register for it.

There are 75 seats available for this event.

Note: The deadline for registrations is January 13th, 2023!

This year at CppCon 2022, I gave the following session:

• “C++23 What’s In It For You?”

You can find the slides of the session below.

After a long break due to the Corona pandemic, I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Tuesday June 28th, 2022 at 18:00 at Vandewiele Experience Center.

Vandewiele ( https://www.vandewiele.com/ ) is sponsoring this event by providing the location, drinks and catering.

The agenda is as follows:

• 18:00: Reception with food.
• 18:30: Session 1: Minimal Logging Framework in C++ 20 (Koen Poppe)
  As developers, adding log statements seems easy and risk-free. However, with hundreds of machines, collecting those log files can become quite a challenge, let alone making sense of the important information they contain. We set out to reduce logging to its essentials and explore optimisations not only in terms of disk space, but also runtime performance and even exposure. Leveraging ideas from well-known software related workflows, we will write a C++20 logging framework from scratch and highlight some surprises along the way.
• 19:30: Break
• 19:45: Session 2: Modern CMake (Lieven de Cock)
  CMake is a cross-platform open source software for managing the build process in a portable fashion. We will have a look at the basics of modern CMake. The old, pre modern cmake way should be considered obsolete, for very good reasons. We will talk about targets, build types, dependencies, usage specifications, …, a quick look on cross compilation, and using 3rd party libraries.
• 20:45: Introduction to Vandewiele, followed by a drink.

We will be giving away 2 copies of Professional C++, 5th Edition.

The event is free for everyone, but you need to register for it.

There are 30 seats available for this event.

Note: The deadline for registrations is June 22th, 2022!

On 24th of May 2022 I gave the following session at CppEurope 2022:

• “A Look Ahead At C++23”

You can find the slides of the session below.

Here’s the official announcement slide:

Microsoft just announced that their STL included with Visual C++ is now C++20 feature complete. This is the case for:

• Visual Studio 2022 version 17.2
• Visual Studio 2019 version 16.11.14

All C++20 features are now available under the /std:c++20 compiler flag.

You can read the full announcement here.