Template meta-programming is one of C++'s most powerful features, enabling developers to perform computations at compile-time rather than run-time. This paradigm allows for type-safe, efficient, and highly flexible code. In this article, we'll explore the basics of template meta-programming and examine some practical examples.

The Problem: Type Repetition

Consider a function that calculates the Euclidean distance between two points in a 2D space. A straightforward implementation for float types might look like this:

float
distance(float a1, float a2, float b1, float b2)
{
    float tmp1 = a1 - b1;
    float tmp2 = a2 - b2;
    return std::sqrt(tmp1*tmp1 + tmp2*tmp2);
}

But what if we need the same function for double precision? Without templates, we would need to duplicate our code:

double
distance(double a1, double a2, double b1, double b2)
{
    double tmp1 = a1 - b1;
    double tmp2 = a2 - b2;
    return std::sqrt(tmp1*tmp1 + tmp2*tmp2);
}

This duplication violates the DRY (Don't Repeat Yourself) principle and increases the likelihood of bugs. If we need to update the logic, we'd have to remember to change it in multiple places.

The Solution: Function Templates

C++ templates provide an elegant solution to this problem. We can write a single function template that works with multiple types:

template <typename T>
T
distance(T a1, T a2, T b1, T b2)
{
    T tmp1 = a1 - b1;
    T tmp2 = a2 - b2;
    return std::sqrt(tmp1*tmp1 + tmp2*tmp2);
}

Now, we can call this function with float, double, or any type that supports the required operations (subtraction, multiplication, and square root):

float f_result = distance<float>(1.0f, 2.0f, 3.0f, 4.0f);
double d_result = distance<double>(1.0, 2.0, 3.0, 4.0);

Type Safety with SFINAE

But what if we want to restrict our template to only work with floating-point types? This is where SFINAE (Substitution Failure Is Not An Error) comes in handy.

// Type restrictor using template specialization
template <typename T> struct restrictor { };
template <> struct restrictor<float> { typedef float result; };
template <> struct restrictor<double> { typedef double result; };

// Function template that only works with float or double
template <typename T>
typename restrictor<T>::result
distance(T a1, T a2, T b1, T b2)
{
    T tmp1 = a1 - b1;
    T tmp2 = a2 - b2;
    return std::sqrt(tmp1*tmp1 + tmp2*tmp2);
}

Now, if someone tries to call our function with an integer or another non-floating-point type, they'll get a compile-time error instead of potentially incorrect results or runtime errors.

In modern C++, we might use std::enable_if or concepts (C++20) for cleaner type constraints:

// Using std::enable_if (C++11)
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
distance(T a1, T a2, T b1, T b2)
{
    T tmp1 = a1 - b1;
    T tmp2 = a2 - b2;
    return std::sqrt(tmp1*tmp1 + tmp2*tmp2);
}

// Using concepts (C++20)
template <std::floating_point T>
T distance(T a1, T a2, T b1, T b2)
{
    T tmp1 = a1 - b1;
    T tmp2 = a2 - b2;
    return std::sqrt(tmp1*tmp1 + tmp2*tmp2);
}

Compile-Time Computation: Factorial Example

One of the most powerful aspects of template meta-programming is the ability to perform computations at compile time. Let's compare a traditional runtime factorial implementation with a compile-time template version:

Traditional Runtime Implementation

int factorial(int n) {
    if (n <= 1)
        return 1;
    return n * factorial(n-1);
}

void use_factorial() {
    int result = factorial(4);  // Computed at runtime
    // result = 24
}

Template Meta-Programming Implementation

template <int N>
struct Factorial {
    static const int value = N * Factorial<N-1>::value;  // Recursive template instantiation
};

// Template specialization for base case
template <>
struct Factorial<0> {
    static const int value = 1;
};

void use_factorial() {
    constexpr int result = Factorial<4>::value;  // Computed at compile time
    // result = 24
}

Another Example: Compile-Time Fibonacci

Let's look at another classic example - computing Fibonacci numbers at compile time:

template <int N>
struct Fibonacci {
    static const int value = Fibonacci<N-1>::value + Fibonacci<N-2>::value;
};

// Base cases
template <>
struct Fibonacci<0> {
    static const int value = 0;
};

template <>
struct Fibonacci<1> {
    static const int value = 1;
};

// Usage
constexpr int fib10 = Fibonacci<10>::value;  // 55, computed at compile time

Considerations and Trade-offs

Compiler Considerations

Not all C++ compilers handle template meta-programming equally well:

• GCC (GNU C++ Compiler) typically offers excellent template support and helpful error messages
• Clang also has strong template support with clear diagnostics
• Microsoft Visual C++ had historical limitations, with significant improvements in Visual Studio 2013 and later
• Some older compilers like Borland C++ Builder struggled with complex template code

Conclusion

Template meta-programming is a powerful technique in C++ that enables developers to write more generic, type-safe, and efficient code. By moving computations from runtime to compile time, we can create faster programs with fewer runtime errors.

While it comes with challenges like increased cognitive load and potential debugging difficulties, the benefits often outweigh these drawbacks for many use cases. As with any advanced technique, it's important to use template meta-programming judiciously, where it adds real value to your codebase.

テンプレートメタプログラミングはC++の強力な機能の一つであり、コンパイル時に計算を行う ことで、より効率的で柔軟なコードを作成することができます。この記事がお役に立てば幸いです。