Hi, I'm Tomasz

Recently, while working with a glue code integrating low level C APIs in C++ I stumbled upon a problem where I needed to map enum values to types (and vice-versa).

Problem definition

Imagine you’ve got a factory function:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

enum class FactoryTypes {
    TypeA,
    TypeB,
    TypeC,
};

struct NonCovariantTypeA {};
struct NonCovariantTypeB {};
struct NonCovariantTypeC {};

// TODO what to return here?
// auto create(FactoryTypes t);

Okay, so the create function must be a template but how to determine the return type? Well, mapping from enum Types to any of the types is needed. It’s easy to create one thanks to C++’s constant value template specialisation.

In this post I’m gonna implement a simple type list along with a set of basic operations that can be performed on it.

Tuples?

Isn’t it just a tuple? Not really, it’s something simpler than that. Tuple is a set of values of arbitrary types. Tuples are immutable as well (there’s std::tuple_cat with which operations like append and prepend could be implemented but this will result with a new instance of tuple with extended set of contents).

C++20 provides a small addition to shared_ptr constructor overloads set which is called an aliasing constructor. Quoting after cppreference:

The aliasing constructor: constructs a shared_ptr which shares ownership information with the initial value of r, but holds an unrelated and unmanaged pointer ptr. If this shared_ptr is the last of the group to go out of scope, it will call the stored deleter for the object originally managed by r…

This post is part of a WebAssembly series focused on WASM and C++. The goal is to gain a thorough understanding of how WebAssembly works, how to use it as a compilation target for C++ code and hopefully have fun along the way. So, stick with me for this exciting journey.

Wherever mentioned, working WASM examples will be embedded directly on the page. If your browser supports it, you should be able to see them running.

In this post, I’m gonna discuss how C++23 helps to write better worker threads and saves you the effort to manually manage thread termination.

What are worker threads?

I’m sure that every one has written a worker thread one time or another and it’s impossible not to find (at least) one in any bigger code base. Usually, worker threads are responsible for performing background tasks, like doing some calculations in an asynchronous manner, performing network downloads, job dispatchers, IPC message brokers etc. Basically, if you see a thread and a while loop inside - you’ve got a worker thread!

Here’s a quick overview of my repo setup for any new C++ projects that I create. I’m gonna start with an empty repo and bring it up to an initial stage where all my preferred tooling is available and ready.

Empty repo scaffolding

Here’s the link to the repo, if you’re not interested in the walk through.

Build system

Starting with an empty git repo, first thing I like to do is just to create main.cpp with an empty main function. I use vim-luasnips so, creating that is instantaneous.

This post is part of a WebAssembly series focused on WASM and C++. The goal is to gain a thorough understanding of how WebAssembly works, how to use it as a compilation target for C++ code and hopefully have fun along the way. So, stick with me for this exciting journey.

Wherever mentioned, working WASM examples will be embedded directly on the page. If your browser supports it, you should be able to see them running.