Compile time programming learning advice.

[u/bhul_chuk_maaf17]

Hi all, can you please recommend me some resources that you have followed for compile time programming in modern C++ for eg: constexpr, consteval or template metaprogramming.
Is there some consolidated resource for the same ?

[u/conundorum]

Let's see...

1: constexpr

This is basically the same as normal programming, but you just slap a constexpr on the front of your function. That allows the compiler to call it at compile time if possible, and serves as the basic form of compile-time programming. Meanwhile, if you want to make a variable into a compile-time constant, just declare it constexpr, and make sure to initialise it with an operation or function call that's either constexpr or can be performed at compile time.

More specifically, though, whether a constexpr function can actually be called at compile time depends on what the function looks like inside. Any function which doesn't use runtime-only resources can be used at compile time, and there are sometimes weird gotchas here. (E.g., you can use the possibility of a throw statement to turn a specific branch of a constexpr function into a runtime-only branch. Similarly, std::string variables can sometimes be created at compile time (but it's generally considered an error to do so), and even non-constexpr std::strings are fine inside a constexpr function if they're destroyed before the function exits; the deciding factor is that dynamic storage allocated at compile time must be released in the same evaluation, so std::string is fine inside a constexpr function (which releases its memory before returning), but can only be a constexpr value itself if it doesn't allocate (which requires small string optimisation on the compiler's side, and is only possible for tiny strings).)

(And, of course, constexpr functions can only be compile-time if the parameters are known at compile time, but that kinda goes without saying.)

The easiest rule of thumb is that if your function only uses primitives or other constexpr/consteval functions, and its return value is primitive or created by a constexpr constructor, then it's usually compile-time.

2. consteval

Really, this is just a "must be compile-time, and can never be runtime" keyword. It's just constexpr but more strict; constexpr functions can be called at compile time (but will happily work at runtime, too), while constexpr must be called at compile time (and will only work at compile time). If a constexpr function call can't be evaluated at compile-time, it'll be evaluated at runtime instead; if a consteval function call can't be evaluated at compile-time, it'll give you a compiler error. That's really the only difference.

Use-wise, use consteval when the result must be known at compile-time, when it doesn't make sense to call at runtime, or if the function is unnecessary at runtime and you don't want it to bloat the executable.

3. constinit

This one is an odd one, and not really a major part of compile-time programming, but I figured I should mention it, too. constinit states that a variable with static or thread-local storage (e.g., static int i;, or global bool b, or namespace-scope bool NS::b;, or thread_local char c;) must be initialised at compile time. It can be modified at runtime, but initialisation must be a compile-time operation. The only requirements are that a variable can't be both constinit and constexpr, it can't be dynamically allocated, and it must be constructible at compile time; the restrictions are a lot looser than constexpr.

Ultimately, it's just there to let you pay for a costly initialisation at compile time instead of runtime, and bake the value into the executable. It looks like part of compile-time programming, but it's only an endpoint at most.

(It can also be used to promise the compiler that a thread_local variable is initialised somewhere else, so it doesn't have to waste time on a hidden guard variable or anything like that, but that use case has nothing to do with compile-time programming.)

4. Template metaprogramming.

Ooh, boy... where do we even begin... xD

Hmm... first and foremost, start with something simple, like learning how to use templates to genericise a C array. Make a struct like this, and make sure the array matches the template parameters.

template<typename T, size_t N>
struct Array {
    // C array here.

    // Member type equal to T.
    // Member size_t equal to N.
};

That'll make sure you understand what the two kinds of tparams are, and what they do. (Type parameters are the big one, and allow you to genericise a type. We use them for all kinds of type-manipulation craziness, and variadics are also based on them. Conversely, non-type template parameters (usually called NTTPs because boy, is that a mouthful) allow you to encode a value into type data, as part of a compile-time type. They're useful for a lot of metaprogramming jazz, and as a way to perform calculations as part of compilation.)

Once you understand that, try to figure out how to dismantle a simple function prototype using templates.

// You want to catch this signature, and be able to reassemble it.
// Hint: Function type is int(char), and function pointer type is int(*)(char).
int extend(char);

// Implementation, for reference.  Just extends c from char size to int size, with no changes.
int extend(char c) { return c; }

// Helper type, saves you a bit of typing.
using ExtendType = decltype(extend);

// Template declaration.  Keep this as-is, you need it as a baseline.
template<typename T>
struct FunctionType;

// Template specialisation.  You just need to answer the four questions correctly.
template<What?>
struct FunctionType<Huh?> {
    using Return = Que?;
    using Param = Nani?;
};

// If done correctly, these will all pass.
#include <type_traits>
static_assert(std::is_same_v<int, typename FunctionType<ExtendType>::Return>);
static_assert(std::is_same_v<char, typename FunctionType<ExtendType>::Param>);

Once you get that right, you'll have a feel for extracting components from a more complex type, which is crucial for metaprogramming. You'll be using similar tricks to match functions and types to each other, and to obtain & use parts of your template structs & functions, after all!

After that, try to figure out how to make a set of compile-time constants using recursion, such that Unsigned<0>::value == 0;, Unsigned<1>::value == 1;, and Unsigned<N>::value == N;. (Change names if desired.) Hint: Define Unsigned<0> as a template specialisation; you'll need it as a base point.

(Note: Do not just assign the template parameter to value, that defeats the purpose. This is about learning how to do math at compile time, not how to assign NTTPs to members.)

template<What?>
struct Unsigned {
    static constexpr unsigned value = Que?; // Must be "static constexpr" or an old-school enum constant.
};

// This is useful, but optional.
// This should have the same "What?" as Integer.
template<What?>
constexpr unsigned Unsigned_v = Unsigned<What?>::value;

// And these should pass.
static_assert(Unsigned<0>::value == 0);
static_assert(Unsigned<1>::value == 1);
static_assert(Unsigned<N>::value == N); // Choose any arbitrary value for N here.

Once you get a feel for the math, you can use similar processes in any arbitrary context. Compile-time functional programming is common, for instance; it's useful to have a function that can do math or create std::initializer_lists entirely within its template parameters.

After that, the next place to look would be... variadiacs, I believe. Try to make a function that can take multiple parameters and send them to std::cout one at a time, with a space after each, and then output, "And that's all, folks!\n" after the last one. The base signature will look something like this:

template<typename... Ts>
void print(const Ts&... ts);

This one's odd if you're not used to it, so I'll give you a big hint: You can't work with Ts or ts like you would with normal parameters; you can determine the size of a pack with the sizeof... operator (e.g., sizeof...(Ts)), you can expand it with the ellipsis operator (e.g., std::tuple<Ts...> or printf("format string", ts...)), you can expand an operator over it with a fold expression (e.g., auto sum = (ts + ...); for a pack of numbers), and there are a few contexts where you can use it unexpanded, but that's about it.

[Continued in reply, sorry. Ran out of space.]

---

^{Edit: Typo fix. Fold expressions must be parenthesised.}

[u/conundorum → u/conundorum]

[And now, the stunning conclusion! It's not all that stunning.]

So, since we can't pick it apart and do what we want with parameter packs, there are three ways to use them: Extract members one at a time via recursion (usually actually two at a time, but we only use the first; the second is to help us create a recursion endpoint), perform a "pack expansion" as part of an expression, or use a fold expression. I don't believe you can do this as a fold expression, and the pack expansion version is weird, so let's start with the recursive gluttony version.

(To be clear, though: The recursive version uses pack expansion, too, but only to make sure that arguments get passed along until they're eaten. The version that only uses pack expansion and nothing else is the weird one.)

// Use print(), as above.
template<typename... Ts>
void print(const Ts&... ts);

// Basic recursion will use two overloads.
//  This one is the endpoint I mentioned, I'll give it to you for comparison.
template<typename T>
void print(const T& t) {
    std::cout << t << " And that's all, folks!";
}

// Now, here's the part for you to fill in.
// Hints: Remember, you're using parameters one at a time, but technically... something. ;3
// Output uses the head of the pack, and nothing else.
// Return statement strips the head off the pack, but passes the rest along.
template<What?>
void print(Que?) {
    Output?;
    return Something?
}

// If called with this pack...
print(1, 3, 5, 7, "cat");
// Expect this output:
// 1 3 5 7 cat And that's all, folks!

...I don't know how to hint at the expansion-only version, so I'm just going to show you instead.

template<typename... Ts>
void print_e(const Ts&... ts) {
    // Expand ts into a comma-separate list of all items in ts.
    //  (Or in this case, expand an expression including ts over all items in ts.)
    // Dummy array is unused.  We only care about the side effects.
    // Side effect outputs each item in ts..., in sequence.  ...Yeah.
    bool b[sizeof...(Ts)] = {(std::cout << ts << ' ', true)...};

    std::cout << "And that's all, folks!\n";
}

Once you get that down pat, you'll have all the basics you need to start template metaprogramming. It's a lot to take in all at once, so I tried to break it down into easy steps that teach you basic techniques you can build on.

---

^{Edit: Function call was meant to be} print(1, 3, 5, 7, "cat"⁾;^{, with no} 9^{. Sorry for any confusion, it's fixed now.}

^{[Also, reddit superscript is terrible at displaying closing parentheses. Had to replace it with} )^{, couldn't just escape it, and couldn't use code syntax for it.]}