Templates & Compile-Time Polymorphism

#include 
#include 

// Generic saturating add — works for any integer type, no runtime overhead
template
T saturating_add(T a, T b) noexcept {
    static_assert(std::is_integral::value, "T must be an integer type");
    if (b > 0 && a > std::numeric_limits::max() - b) {
        return std::numeric_limits::max();
    }
    if (b < 0 && a < std::numeric_limits::min() - b) {
        return std::numeric_limits::min();
    }
    return static_cast(a + b);
}

// Clamp: constrain value to [lo, hi]
template
constexpr T clamp(T val, T lo, T hi) noexcept {
    static_assert(std::is_arithmetic::value, "T must be numeric");
    return (val < lo) ? lo : (val > hi) ? hi : val;
}

// Usage: compiler generates one specialisation per type called with
int16_t temp_safe = saturating_add(INT16_MAX - 5, 10); // = INT16_MAX
uint8_t duty = clamp(raw_duty, 0u, 100u);

#include 
#include 
#include 

// Statically-sized ring buffer: size and type are template parameters
// Zero heap allocation; all memory in the object itself
template
class RingBuffer {
    static_assert((N & (N - 1u)) == 0u, "N must be a power of 2");
    static constexpr std::size_t MASK = N - 1u;
public:
    RingBuffer() noexcept : m_head(0u), m_tail(0u) {}

    // Push: returns false if full
    bool push(const T &item) noexcept {
        std::size_t next = (m_head + 1u) & MASK;
        if (next == m_tail) { return false; }  // full
        m_buf[m_head] = item;
        m_head = next;
        return true;
    }

    // Pop: returns false if empty
    bool pop(T &item) noexcept {
        if (m_head == m_tail) { return false; }  // empty
        item = m_buf[m_tail];
        m_tail = (m_tail + 1u) & MASK;
        return true;
    }

    std::size_t size() const noexcept { return (m_head - m_tail) & MASK; }
    bool empty() const noexcept { return m_head == m_tail; }
    bool full()  const noexcept { return ((m_head + 1u) & MASK) == m_tail; }

private:
    std::array m_buf;
    volatile std::size_t m_head;
    volatile std::size_t m_tail;
};

// Static allocation: sizeof determined at compile time
static RingBuffer g_can_rx_buf;  // 16 * sizeof(CanFrame_t) bytes
static RingBuffer g_uart_rx_buf; // 256 bytes

#include 

// constexpr: computed at compile time — zero runtime overhead
// Replaces error-prone macros for configuration constants

constexpr uint32_t CPU_FREQ_HZ    = 300'000'000u;  // 300 MHz
constexpr uint32_t US_PER_SECOND  = 1'000'000u;
constexpr uint32_t TICKS_PER_US   = CPU_FREQ_HZ / US_PER_SECOND;  // = 300

// constexpr function: result known at compile time if args are constexpr
constexpr uint32_t ms_to_ticks(uint32_t ms) noexcept {
    return ms * (CPU_FREQ_HZ / 1000u);
}

// Static assert: verify at compile time, not runtime
static_assert(TICKS_PER_US == 300u, "TICKS_PER_US calculation error");
static_assert(ms_to_ticks(10u) == 3'000'000u, "ms_to_ticks error");

// constexpr CRC table: computed once at compile time, stored in flash as const array
constexpr auto make_crc8_table() noexcept {
    std::array table{};
    for (uint16_t i = 0u; i < 256u; ++i) {
        uint8_t crc = static_cast(i);
        for (uint8_t j = 0u; j < 8u; ++j) {
            crc = (crc & 0x80u) ? static_cast((crc << 1u) ^ 0x07u)
                                 : static_cast(crc << 1u);
        }
        table[i] = crc;
    }
    return table;
}
static constexpr auto CRC8_TABLE = make_crc8_table();  // computed at compile time