Variadic Templates in C++ — Parameter Packs, Fold Expressions and Real-World Patterns

#include <iostream>
#include <string>
#include <typeinfo>

// Template parameter pack: 'Types' holds zero or more types.
// Function parameter pack: 'args' holds the matching runtime values.
template <typename... Types>
void inspectArguments(Types... args) {
    // sizeof... is resolved at compile time — no runtime cost.
    std::cout << "Number of arguments: " << sizeof...(args) << "\n";

    // Pack expansion inside an initialiser list.
    // The comma-separated initialiser forces left-to-right evaluation order.
    // We use an int array as a dummy to drive the expansion.
    int dummy[] = {
        (std::cout << "  value=" << args
                   << "  type=" << typeid(args).name() << "\n", 0)...
    };
    // Suppress unused-variable warnings without a runtime branch.
    (void)dummy;
}

// Demonstrating pack expansion in a base-class list (mixin pattern).
struct Flyable  { void fly()   { std::cout << "Flying\n"; } };
struct Swimmable{ void swim()  { std::cout << "Swimming\n"; } };
struct Runnable { void run()   { std::cout << "Running\n"; } };

template <typename... Capabilities>
struct Animal : public Capabilities... {
    // Inherits every capability passed as a template argument.
    // 'using Capabilities::*...' would be needed for ambiguous overloads.
};

int main() {
    inspectArguments(42, 3.14, std::string("hello"), true);

    std::cout << "\n";

    // Animal inherits fly(), swim(), and run() — resolved at compile time.
    Animal<Flyable, Swimmable, Runnable> duck;
    duck.fly();
    duck.swim();
    duck.run();

    return 0;
}

#include <iostream>
#include <string>
#include <sstream>

// ── APPROACH 1: Classic recursive unpacking (C++11 compatible) ──────────────

// Base case: no arguments left — recursion bottoms out here.
void printRecursive() {
    std::cout << "\n";
}

// Recursive case: handle the first argument, then recurse on the rest.
template <typename First, typename... Rest>
void printRecursive(First first, Rest... rest) {
    std::cout << first;
    if (sizeof...(rest) > 0) std::cout << ", ";
    printRecursive(rest...); // Peel one argument, recurse.
}

// ── APPROACH 2: C++17 fold expressions ──────────────────────────────────────

// Unary right fold with operator+: sum any number of numeric args.
template <typename... Numbers>
auto sumAll(Numbers... numbers) {
    return (numbers + ...); // Expands to: n0 + (n1 + (n2 + ...))
}

// Binary left fold with initial value — safe for empty packs.
template <typename... Numbers>
auto sumWithDefault(Numbers... numbers) {
    return (0 + ... + numbers); // 0 is the identity; empty pack returns 0.
}

// Fold over operator<< to print to any stream — a pattern you'll see in
// logging libraries.
template <typename... Args>
std::string buildString(Args... args) {
    std::ostringstream stream;
    // Left fold: stream << arg0, then stream << arg1, etc.
    // The cast to void suppresses nodiscard warnings on some compilers.
    (stream << ... << args);
    return stream.str();
}

// Fold over operator&& — compile-time-friendly "all of" check.
template <typename... Predicates>
bool allTrue(Predicates... predicates) {
    return (... && predicates); // Short-circuits just like normal &&.
}

int main() {
    std::cout << "Recursive print: ";
    printRecursive(1, 2.5, std::string("three"), '4');

    std::cout << "Sum (fold):         " << sumAll(1, 2, 3, 4, 5) << "\n";
    std::cout << "Sum empty pack:     " << sumWithDefault() << "\n";
    std::cout << "Built string:       " << buildString("Score=", 42, ", Rank=", 1) << "\n";
    std::cout << "All positive checks: "
              << std::boolalpha
              << allTrue(1 > 0, 2 > 0, 3 > 0) << "\n";
    std::cout << "All positive checks: "
              << allTrue(1 > 0, -1 > 0, 3 > 0) << "\n";

    return 0;
}

#include <iostream>
#include <string>
#include <sstream>
#include <tuple>
#include <utility>
#include <memory>
#include <chrono>

// ══════════════════════════════════════════════════════════════════════════
// PATTERN 1: Type-safe variadic logger
// No undefined behaviour, no format strings, works with any printable type.
// ══════════════════════════════════════════════════════════════════════════

enum class LogLevel { Info, Warning, Error };

namespace detail {
    // Base case: nothing left to write.
    void writeToStream(std::ostream&) {}

    // Recursive: write the first token, then recurse on the rest.
    template <typename Head, typename... Tail>
    void writeToStream(std::ostream& out, Head&& head, Tail&&... tail) {
        out << std::forward<Head>(head);
        writeToStream(out, std::forward<Tail>(tail)...);
    }
}

template <typename... MessageParts>
void logMessage(LogLevel level, MessageParts&&... parts) {
    const char* levelTag =
        level == LogLevel::Info    ? "[INFO]   " :
        level == LogLevel::Warning ? "[WARN]   " : "[ERROR]  ";

    // Write everything into a buffer first for atomic output
    // (important in multithreaded contexts — avoids interleaved lines).
    std::ostringstream buffer;
    buffer << levelTag;
    // Perfect-forward each part — no copy if callers pass rvalues.
    detail::writeToStream(buffer, std::forward<MessageParts>(parts)...);

    std::cout << buffer.str() << "\n";
}

// ══════════════════════════════════════════════════════════════════════════
// PATTERN 2: tuple_for_each — iterate over every element in a tuple
// Uses index_sequence to generate compile-time indices.
// ══════════════════════════════════════════════════════════════════════════

namespace detail {
    // The actual worker: expands index pack and calls the callable per element.
    template <typename TupleType, typename Callable, std::size_t... Indices>
    void tupleForEachImpl(TupleType&& tpl, Callable&& fn,
                          std::index_sequence<Indices...>) {
        // Fold over operator, to call fn for each index in order.
        // std::get<Indices>(tpl) extracts element Indices from the tuple.
        (fn(std::get<Indices>(std::forward<TupleType>(tpl))), ...);
    }
}

template <typename TupleType, typename Callable>
void tupleForEach(TupleType&& tpl, Callable&& fn) {
    // std::tuple_size deduces N; index_sequence_for generates 0,1,...,N-1.
    detail::tupleForEachImpl(
        std::forward<TupleType>(tpl),
        std::forward<Callable>(fn),
        std::make_index_sequence<
            std::tuple_size<std::remove_reference_t<TupleType>>::value>{}
    );
}

// ══════════════════════════════════════════════════════════════════════════
// PATTERN 3: Type-safe factory with perfect forwarding
// Mirrors how std::make_unique / emplace_back work internally.
// ══════════════════════════════════════════════════════════════════════════

struct NetworkConnection {
    std::string host;
    int port;
    int timeoutMs;

    NetworkConnection(std::string h, int p, int t)
        : host(std::move(h)), port(p), timeoutMs(t) {
        std::cout << "  [NetworkConnection] Connecting to "
                  << host << ":" << port
                  << " (timeout=" << timeoutMs << "ms)\n";
    }
};

// Factory: constructs any type T, forwarding all constructor args.
// This is exactly what std::make_unique does under the hood.
template <typename ObjectType, typename... ConstructorArgs>
std::unique_ptr<ObjectType> makeManaged(ConstructorArgs&&... args) {
    return std::make_unique<ObjectType>(
        std::forward<ConstructorArgs>(args)... // Each arg keeps its value category.
    );
}

int main() {
    // ── Pattern 1: Logger ──────────────────────────────────────────────────
    std::string endpoint = "/api/users";
    int statusCode = 404;

    logMessage(LogLevel::Info,    "Server started on port ", 8080);
    logMessage(LogLevel::Warning, "Slow query on endpoint ", endpoint,
               " — took 1200ms");
    logMessage(LogLevel::Error,   "Unexpected status ", statusCode,
               " for ", endpoint);

    std::cout << "\n";

    // ── Pattern 2: tuple_for_each ─────────────────────────────────────────
    auto configTuple = std::make_tuple(
        std::string("localhost"), 5432, true, 3.14
    );

    std::cout << "Config values:\n";
    tupleForEach(configTuple, [](const auto& value) {
        // 'auto' in a lambda parameter is effectively a mini-template —
        // the lambda is instantiated for each distinct element type.
        std::cout << "  " << value << "\n";
    });

    std::cout << "\n";

    // ── Pattern 3: Perfect-forwarding factory ─────────────────────────────
    std::cout << "Creating managed connection:\n";
    auto conn = makeManaged<NetworkConnection>("db.prod.internal", 5432, 3000);
    // conn owns the object; destroyed automatically at scope exit.

    return 0;
}

#include <iostream>
#include <initializer_list>
#include <vector>
#include <numeric>
#include <type_traits>

// ── OPTION A: initializer_list — same-type, runtime count ─────────────────
// Prefer this when all values share one type. Single instantiation.
double averageHomogeneous(std::initializer_list<double> values) {
    if (values.size() == 0) return 0.0;
    double total = std::accumulate(values.begin(), values.end(), 0.0);
    return total / static_cast<double>(values.size());
}

// ── OPTION B: Variadic template — heterogeneous, compile-time types ────────
// Justified here because we want to accept mixed numeric types and
// convert them all to double without the caller having to cast.
template <typename... Numbers>
double averageHeterogeneous(Numbers... values) {
    static_assert(sizeof...(values) > 0,
        "averageHeterogeneous requires at least one argument");
    // Each element in the pack may be int, float, long, etc.
    // The fold converts each via double() before summing.
    double total = (static_cast<double>(values) + ...);
    return total / static_cast<double>(sizeof...(values));
}

// ── Demonstrating compile-time type constraints with if constexpr ──────────
// if constexpr lets us branch on type properties without
// runtime overhead — the discarded branch isn't even compiled.
template <typename... Types>
void describeTypes(Types... args) {
    auto describe = [](const auto& value) {
        using T = std::decay_t<decltype(value)>;
        if constexpr (std::is_integral_v<T>) {
            std::cout << "  integer(" << value << ")\n";
        } else if constexpr (std::is_floating_point_v<T>) {
            std::cout << "  float("   << value << ")\n";
        } else {
            std::cout << "  other("   << value << ")\n";
        }
    };
    // Fold over operator, to call describe for each arg in order.
    (describe(args), ...);
}

int main() {
    // All doubles — initializer_list is the right call here.
    std::cout << "Homogeneous average: "
              << averageHomogeneous({10.0, 20.0, 30.0}) << "\n";

    // Mixed numeric types — variadic template earns its keep.
    std::cout << "Heterogeneous average: "
              << averageHeterogeneous(10, 20.5f, 30L) << "\n";

    std::cout << "\nType descriptions:\n";
    describeTypes(42, 3.14, 'A', std::string("hello"));

    return 0;
}