C++ Templates — Exponential Code Bloat Crashes Production

#include <iostream>
#include <string>

namespace io::thecodeforge {

    // Function Template: Generic Swap
    template <typename T>
    void forge_swap(T& a, T& b) {
        T temp = a;
        a = b;
        b = temp;
    }

    // Class Template: Generic Storage Box
    template <typename T>
    class Box {
    private:
        T content;
    public:
        Box(T val) : content(val) {}
        T get_content() const { return content; }
        void set_content(T val) { content = val; }
    };
}

int main() {
    using namespace io::thecodeforge;

    int x = 10, y = 20;
    forge_swap(x, y);
    std::cout << "Swapped ints: " << x << ", " << y << std::endl;

    Box<std::string> stringBox("TheCodeForge");
    std::cout << "Box contains: " << stringBox.get_content() << std::endl;

    return 0;
}

#include <iostream>
#include <cstring>

namespace io::thecodeforge {

    // Primary Template
    template <typename T>
    bool is_equal(T a, T b) {
        return a == b;
    }

    // Full Specialization for C-strings (const char*)
    template <>
    bool is_equal<const char*>(const char* a, const char* b) {
        std::cout << "[Specialized for C-strings] ";
        return std::strcmp(a, b) == 0;
    }
}

int main() {
    using namespace io::thecodeforge;

    std::cout << "Int comparison: " << is_equal(5, 5) << std::endl;
    std::cout << "String comparison: " << is_equal("Forge", "Forge") << std::endl;

    return 0;
}

#include <iostream>
#include <type_traits>

namespace io::thecodeforge {

    // Forward reference: T&& binds to lvalues and rvalues
    template <typename T>
    void forward_deduction(T&& arg) {
        if constexpr (std::is_lvalue_reference_v<T>) {
            std::cout << "Lvalue: " << arg << std::endl;
        } else {
            std::cout << "Rvalue: " << arg << std::endl;
        }
    }

    // Deduction failure example
    template <typename T>
    T mean(T a, T b);  // both arguments must be same type
}

int main() {
    using namespace io::thecodeforge;

    int x = 42;
    forward_deduction(x);    // deduces T&, prints Lvalue
    forward_deduction(99);   // deduces T, prints Rvalue

    // mean(3, 4.5);  // error: deduced conflicting types

    return 0;
}

#include <iostream>
#include <string>

namespace io::thecodeforge {

    // Fold expression: sum all arguments
    template <typename... Args>
    auto sum(Args... args) {
        return (args + ...);  // unary right fold
    }

    // Fold expression with initial value: concatenate strings with separator
    template <typename... Args>
    std::string join(const std::string& sep, Args... args) {
        return (args + ... + sep);  // binary left fold, beware: appends sep after each
    }

    // Print all arguments (using comma operator)
    template <typename... Args>
    void print_all(Args... args) {
        ((std::cout << args << " "), ...);  // unary right fold over comma
        std::cout << std::endl;
    }
}

int main() {
    using namespace io::thecodeforge;

    std::cout << "Sum: " << sum(1, 2, 3, 4, 5) << std::endl;  // 15
    std::cout << "Sum of doubles: " << sum(1.1, 2.2, 3.3) << std::endl;  // 6.6

    // join: note the trailing separator
    std::cout << "Joined: " << join("-", "a", "b", "c") << std::endl;  // "a-b-c-"

    print_all("Hello", 42, 3.14, "world");

    return 0;
}

#include <iostream>
#include <type_traits>

namespace io::thecodeforge {

    // Enable only for integral types
    template <typename T,
              typename = typename std::enable_if<std::is_integral<T>::value>::type>
    T half(T value) {
        return value / 2;
    }

    // Enable only for floating point types
    template <typename T,
              typename = typename std::enable_if<std::is_floating_point<T>::value>::type>
    T half(T value) {
        return value / 2.0;
    }

    // Use with void return using SFINAE
    template <typename T>
    typename std::enable_if<std::is_arithmetic<T>::value, void>::type
    print_arithmetic(T value) {
        std::cout << "Arithmetic: " << value << std::endl;
    }
}

int main() {
    using namespace io::thecodeforge;

    std::cout << half(10) << std::endl;      // calls integral version -> 5
    std::cout << half(3.14) << std::endl;    // calls floating point version -> 1.57

    print_arithmetic(42);
    // print_arithmetic("string");  // error: no matching function (SFINAE removes it)

    return 0;
}

#include <iostream>

namespace io::thecodeforge {

    // Compile-time factorial via template metaprogramming
    template <unsigned int N>
    struct Factorial {
        enum { value = N * Factorial<N - 1>::value };
    };

    // Base case
    template <>
    struct Factorial<0> {
        enum { value = 1 };
    };

    // Modern constexpr equivalent
    constexpr unsigned int factorial_constexpr(unsigned int n) {
        return (n <= 1) ? 1 : n * factorial_constexpr(n - 1);
    }
}

int main() {
    using namespace io::thecodeforge;

    std::cout << "Factorial<5>::value = " << Factorial<5>::value << std::endl;  // 120
    std::cout << "factorial_constexpr(5) = " << factorial_constexpr(5) << std::endl; // 120

    // Use compile-time value as array size
    int arr[Factorial<4>::value];  // sized 24
    std::cout << "Size of arr: " << sizeof(arr) / sizeof(arr[0]) << std::endl;

    return 0;
}