Hi, I'm Tomasz

Welcome to the second part of the series about dependency and package management in C++ projects. This time I’m gonna focus on somewhat less popular solutions than the main three.

Overview

Let’s evaluate if any of these are worth the hassle.

Hunter

Hunter caters towards CMake. The way it works is really similar to meson’s wraps (with the only difference that it’s not built into CMake). Usage is fairly simple. You have to export HUNTER_ROOT to a location of choice. Hunter will use it to store its build directories and obtained source code. There’s nothing that has to be installed. It’s kind of “self bootstrapping”. You have to download HunterGate within your CMake project:

This post is a quick reminder to self regarding specifics of RPATH, RUNPATH, LD_LIBRARY_PATH, LD_RUN_PATH and the lookup order.

Refresher (a very short one)

RPATH, RUNPATH - are entries in the ELF header, baked into the binary allowing the dynamic loader to lookup its shared dependencies.

RPATH/RUNPATH can be specified directly, using a linker option (-rpath):

g++ -Wl,-rpath=path/for/rpath

If missing in the command line, RPATH can be set using LD_RUN_PATH variable.

In this post I’m gonna do a short overview of package management and vendoring solutions for C++. This is a controversial topic. Still, there’s no official standardised package manager however, there’s a plethora of solutions (some more mature than others) which I think solve the problem well (at least as far as I’m concerned). I planned to publish the entire overview in a single post however, there’s a lot of material to cover and eventually I had to split it up into multiple parts.

Let’s suppose that you’re working with a virtual interface defined as follows:

1
2
3
4
5

struct I {
    virtual ~I() = default;

    virtual void process(int) = 0;
};

Now, let’s have a class A that implements this interface:

1
2
3

struct A : I {
    void process(int) override {}
};

So far so good. Now, let’s say you want to add an overloaded version of process in class B. This would look like so:

1
2
3

struct B : A {
    void process(std::string) {}
};

An attempt to use this class’s original interface like so:

zmq_poll is used to monitor multiple sockets for events. The API is very simple. zmq_poll takes a pointer to an array of zmq_pollitem_t structures, the number of items in the array, and a timeout value in milliseconds. Each zmq_pollitem_t in the array acts both as an input and an output. The input part is used to specify the socket to monitor and the events to monitor for. The output part is used to report the events that occurred on the socket. Here’s how you’d typically use zmq_poll:

Recently I’ve been doing a lot of template meta-programming in C++. As we all know, when writing a class or a function template, the definition must be in the header file. This is because the compiler needs to see the definition of the template in order to instantiate it. There are some exceptions to this rule. The restriction doesn’t apply if you explicitly instantiate the template in the source file (and of course limit the template’s use to the set of types you’ve instantiated it with). But there’s one more exception, which I think, is not very widely known - full template specialisation.

I was initially sceptical about just task runner. I wasn’t really convinced that it’s a tool solving a real problem and thought of it more as a gimmick. Finally, I decided to give it a try to form a more informed opinion. Below are some of my observations.

It’s just a command executor

In essence, that’s everything just is. You create a justfile in which you define tasks. Each task is a set of steps. Each step is executed in a separate shell instance. It’s possible to define dependencies between tasks. Here’s a basic justfile example: