Embedded C++: constexpr, Templates, and Toolchains for Real-Time Systems

Embedded systems power everything from medical implants to automotive controllers. While C remains dominant, C++ offers powerful abstractions that don't sacrifice performance—if used correctly. This tutorial dives into three pillars of modern embedded C++: constexpr for compile-time computation, templates for zero-overhead polymorphism, and toolchains for cross-compilation. You'll learn how to write code that runs efficiently on microcontrollers with kilobytes of RAM and megahertz clocks. We'll explore real-world scenarios like sensor fusion, real-time control loops, and memory-mapped peripherals. By the end, you'll be able to leverage C++'s strengths without falling into traps like code bloat or unpredictable timing. Whether you're porting a legacy C codebase or starting a new IoT project, these techniques will help you write safer, faster, and more maintainable embedded software.

1. constexpr in Embedded Contexts

constexpr functions and variables are evaluated at compile-time, eliminating runtime overhead. In embedded systems, this is critical for lookup tables, configuration constants, and compile-time checks. However, constexpr has limitations: recursion depth (typically 512), no dynamic allocation, and no undefined behavior. Use constexpr for CRC tables, sine waves, or filter coefficients. Example: a compile-time sine table for motor control.

#include <array>
#include <cmath>

constexpr double PI = 3.14159265358979323846;

constexpr std::array<double, 256> generate_sine_table() {
    std::array<double, 256> table{};
    for (size_t i = 0; i < 256; ++i) {
        table[i] = std::sin(2 * PI * i / 256);
    }
    return table;
}

constexpr auto sine_table = generate_sine_table();

int main() {
    // Use sine_table at runtime
    return 0;
}

2. Templates for Hardware Abstraction

Templates allow writing generic drivers without runtime overhead. For example, a template class for GPIO pins parameterized by port and pin number. The compiler generates separate code for each instantiation, but with careful design, this can be optimized. Use templates for register maps, interrupt handlers, and communication protocols. Example: a template-based SPI driver.

template <uint32_t PortAddr, uint32_t PinMask>
class GpioPin {
public:
    static void set() {
        *reinterpret_cast<volatile uint32_t*>(PortAddr + 0x20) = PinMask; // BSRR
    }
    static void clear() {
        *reinterpret_cast<volatile uint32_t*>(PortAddr + 0x20) = PinMask << 16;
    }
    static bool read() {
        return *reinterpret_cast<volatile uint32_t*>(PortAddr + 0x10) & PinMask; // IDR
    }
};

// Usage
using LedPin = GpioPin<0x40020000, 0x01>; // PA0

int main() {
    LedPin::set();
    // ...
}

3. constexpr and Templates Together

Combine constexpr with templates for powerful compile-time metaprogramming. For example, a constexpr function that computes CRC at compile-time, wrapped in a template for different polynomial widths. This is ideal for bootloaders and communication protocols where CRC tables must be computed without runtime cost.

template <typename T, T Polynomial>
constexpr T crc8(const uint8_t* data, size_t len) {
    T crc = 0;
    for (size_t i = 0; i < len; ++i) {
        crc ^= data[i];
        for (int j = 0; j < 8; ++j) {
            if (crc & 0x80)
                crc = (crc << 1) ^ Polynomial;
            else
                crc <<= 1;
        }
    }
    return crc;
}

constexpr uint8_t data[] = {0x01, 0x02, 0x03};
constexpr auto crc = crc8<uint8_t, 0x07>(data, 3); // CRC-8/MAXIM

int main() {
    static_assert(crc == 0x4B, "CRC mismatch");
    return 0;
}

4. Toolchain Configuration for Embedded Targets

An embedded toolchain includes cross-compiler, linker, and debugger. Key settings: -mcpu, -mthumb, -mfloat-abi, -specs=nano.specs, -ffunction-sections, -fdata-sections, -Wl,--gc-sections. Linker scripts define memory layout: flash, RAM, stack, heap. Example: a minimal linker script for STM32F4.

MEMORY
{
  FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 1M
  RAM (rwx)  : ORIGIN = 0x20000000, LENGTH = 128K
}

SECTIONS
{
  .text : {
    KEEP(*(.isr_vector))
    *(.text*)
    *(.rodata*)
  } > FLASH
  .data : {
    _sdata = .;
    *(.data*)
    _edata = .;
  } > RAM AT > FLASH
  .bss : {
    _sbss = .;
    *(.bss*)
    _ebss = .;
  } > RAM
}

5. Debugging with constexpr and Templates

Debugging template code can be challenging due to complex symbol names. Use static_assert for compile-time checks, and enable RTTI only if necessary. For runtime debugging, use semihosting or serial output. Example: a constexpr function that validates template parameters at compile-time.

template <int N>
constexpr void validate_range() {
    static_assert(N >= 0 && N < 256, "N out of range");
}

template <int N>
class SafeArray {
    static_assert(N > 0, "Array size must be positive");
    int data[N];
public:
    constexpr SafeArray() : data{} {}
};

int main() {
    validate_range<100>(); // OK
    // validate_range<300>(); // compile error
    SafeArray<10> arr;
    return 0;
}

6. Real-World Example: Sensor Fusion with constexpr and Templates

Combine all techniques: a compile-time Kalman filter for IMU data. Use constexpr for matrix operations and templates for different state dimensions. This yields a fast, type-safe filter that runs on a Cortex-M4.

template <size_t N>
class KalmanFilter {
    std::array<double, N> state;
    std::array<double, N*N> covariance;
public:
    constexpr KalmanFilter() : state{}, covariance{} {}
    constexpr void predict(const std::array<double, N*N>& F) {
        // Simplified prediction step
        // In real code, matrix multiplication
    }
    constexpr void update(double measurement) {
        // Update step
    }
};

int main() {
    KalmanFilter<2> filter; // 2D position
    filter.predict({1,0,0,1}); // identity
    return 0;
}