Templates and Compile-Time Code

// function_template.cpp - one function written once, for any type
#include <cstdint>
#include <cstdio>

// T is left open. The compiler writes a real clamp for each type it is used with.
template <typename T>
T clamp(T value, T low, T high) {
    if (value < low) {
        return low;
    }
    if (value > high) {
        return high;
    }
    return value;
}

int main() {
    uint8_t duty = 130;
    int16_t temperature = -55;
    float gain = 1.7f;

    uint8_t d = clamp<uint8_t>(duty, 0, 100);           // T is uint8_t
    int16_t t = clamp<int16_t>(temperature, -40, 125);   // T is int16_t
    float g = clamp(gain, 0.0f, 1.5f);                   // T worked out from the arguments: float

    std::printf("duty %u -> %u\n", static_cast<unsigned>(duty), static_cast<unsigned>(d));
    std::printf("temperature %d -> %d\n", temperature, t);
    std::printf("gain %.1f -> %.1f\n", static_cast<double>(gain), static_cast<double>(g));
    return 0;
}

// deduce_conflict.cpp - the arguments disagree about what T is
#include <cstdint>

template <typename T>
T clamp(T value, T low, T high) {
    return value < low ? low : (value > high ? high : value);
}

uint8_t limit_duty(uint8_t duty) {
    return clamp(duty, 0, 100);
}

// ring_buffer.cpp - a class template: a fixed-size ring buffer, with no heap
#include <cstddef>
#include <cstdint>
#include <cstdio>

// T is the type of each item and N is how many fit. Both are chosen by the user of the class.
template <typename T, size_t N>
class RingBuffer {
public:
    bool push(T item) {
        if (count_ == N) {
            return false;                   // full: refuse, do not overwrite
        }
        items_[head_] = item;
        head_ = (head_ + 1) % N;
        count_++;
        return true;
    }
    bool pop(T &item) {
        if (count_ == 0) {
            return false;
        }
        item = items_[tail_];
        tail_ = (tail_ + 1) % N;
        count_--;
        return true;
    }
    size_t size() const { return count_; }
    static constexpr size_t capacity() { return N; }

private:
    T items_[N] = {};
    size_t head_ = 0;
    size_t tail_ = 0;
    size_t count_ = 0;
};

int main() {
    RingBuffer<uint8_t, 4> rx;              // four bytes from a UART
    for (uint8_t b = 'a'; b <= 'e'; b++) {
        std::printf("push '%c': %s\n", b, rx.push(b) ? "ok" : "full");
    }
    uint8_t byte = 0;
    while (rx.pop(byte)) {
        std::printf("pop '%c'\n", byte);
    }

    RingBuffer<uint16_t, 8> samples;        // eight ADC readings
    samples.push(512);
    std::printf("samples holds %zu of %zu\n", samples.size(), samples.capacity());
    std::printf("sizes: RingBuffer<uint8_t, 4> %zu bytes, RingBuffer<uint16_t, 8> %zu bytes\n",
                sizeof rx, sizeof samples);
    return 0;
}

// constexpr.cpp - values and a whole table worked out by the compiler
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstdio>

constexpr uint32_t clock_hz = 16'000'000;

constexpr uint32_t uart_divisor(uint32_t baud) { return clock_hz / (16u * baud); }

// A CRC-8 table (polynomial 0x07), built by a constexpr function.
constexpr std::array<uint8_t, 256> make_crc8_table() {
    std::array<uint8_t, 256> table{};
    for (unsigned i = 0; i < 256; i++) {
        uint8_t crc = static_cast<uint8_t>(i);
        for (int bit = 0; bit < 8; bit++) {
            if (crc & 0x80u) {
                crc = static_cast<uint8_t>((crc << 1) ^ 0x07);
            } else {
                crc = static_cast<uint8_t>(crc << 1);
            }
        }
        table[i] = crc;
    }
    return table;
}

// constexpr: the whole table is worked out while compiling.
constexpr std::array<uint8_t, 256> crc8_table = make_crc8_table();

static uint8_t crc8(const uint8_t *data, size_t length) {
    uint8_t crc = 0;
    for (size_t i = 0; i < length; i++) {
        crc = crc8_table[static_cast<uint8_t>(crc ^ data[i])];
    }
    return crc;
}

int main() {
    std::printf("divisor for 9600 baud: %u\n", static_cast<unsigned>(uart_divisor(9600)));

    uint32_t baud = 19200;                 // not known while compiling: worked out while running
    std::printf("divisor for %u baud: %u\n", static_cast<unsigned>(baud),
                static_cast<unsigned>(uart_divisor(baud)));

    const uint8_t message[] = {'1', '2', '3', '4', '5', '6', '7', '8', '9'};
    std::printf("crc8_table[1] = 0x%02X, crc8_table[255] = 0x%02X\n", static_cast<unsigned>(crc8_table[1]),
                static_cast<unsigned>(crc8_table[255]));
    std::printf("CRC-8 of \"123456789\": 0x%02X\n", static_cast<unsigned>(crc8(message, sizeof message)));
    return 0;
}

// consteval.cpp - consteval insists on being worked out while compiling
#include <cstdint>

consteval uint32_t divisor_now(uint32_t baud) { return 16000000u / (16u * baud); }

constexpr uint32_t at_9600 = divisor_now(9600);         // fine: 9600 is known while compiling

uint32_t divisor_for(uint32_t baud) {
    return divisor_now(baud);                           // not fine: baud is only known while running
}

// layout.cpp - a register block with one register missing, caught while compiling
#include <cstddef>
#include <cstdint>

struct GpioPort {
    volatile uint32_t MODER;        // 0x00
    volatile uint32_t OTYPER;       // 0x04
    volatile uint32_t OSPEEDR;      // 0x08
                                    // PUPDR, at 0x0C, forgotten
    volatile uint32_t IDR;          // 0x10
    volatile uint32_t ODR;          // 0x14
    volatile uint32_t BSRR;         // 0x18
};

static_assert(offsetof(GpioPort, BSRR) == 0x18, "GpioPort does not match the datasheet");

// power_of_two.cpp - a buffer that only works for sizes that are powers of two
#include <cstddef>
#include <cstdint>

template <typename T, size_t N>
class FastRing {
    static_assert(N != 0 && (N & (N - 1)) == 0, "FastRing size must be a power of two");

public:
    void push(T item) {
        items_[head_] = item;
        head_ = (head_ + 1) & (N - 1);      // a mask instead of %: right only for powers of two
    }

private:
    T items_[N] = {};
    size_t head_ = 0;
};

FastRing<uint8_t, 16> good;
FastRing<uint8_t, 10> bad;

// baud_error.cpp - a UART setting that is too far off, stopped by the build
#include <cstdint>

constexpr uint32_t clock_hz = 16'000'000;

constexpr uint32_t divisor(uint32_t baud) { return clock_hz / (16u * baud); }

// How far the real baud rate is from the one asked for, in tenths of a percent.
constexpr uint32_t error_tenths_of_percent(uint32_t baud) {
    uint32_t actual = clock_hz / (16u * divisor(baud));
    uint32_t difference = actual > baud ? actual - baud : baud - actual;
    return difference * 1000u / baud;
}

static_assert(error_tenths_of_percent(9600) <= 20, "9600 baud is more than 2% off");
static_assert(error_tenths_of_percent(115200) <= 20, "115200 baud is more than 2% off at 16 MHz");

// typed_register.cpp - register fields as types, so a field only fits its own register
#include <cstdint>
#include <cstdio>

// A field is a type: which register it belongs to, where it starts, and how wide it is.
template <typename Reg, unsigned Shift, unsigned Width>
struct Field {
    static_assert(Shift + Width <= 32, "the field does not fit in a 32-bit register");
    static constexpr uint32_t mask = ((1u << Width) - 1u) << Shift;
};

// A register, and the only way to change one of its fields.
template <typename Reg>
class Register {
public:
    explicit Register(volatile uint32_t &word) : word_(word) {}

    template <unsigned Shift, unsigned Width>
    void write(Field<Reg, Shift, Width>, uint32_t value) {
        constexpr uint32_t mask = Field<Reg, Shift, Width>::mask;
        word_ = (word_ & ~mask) | ((value << Shift) & mask);
    }
    uint32_t read() const { return word_; }

private:
    volatile uint32_t &word_;
};

// Tag types: empty structs whose only job is to be different from each other.
struct GpioModer {};
struct UsartCr1 {};

// The fields this program uses, for a made-up chip.
using Pin5Mode = Field<GpioModer, 10, 2>;       // MODER bits 11:10: the mode of pin 5
using UsartEnable = Field<UsartCr1, 13, 1>;     // CR1 bit 13: switch the USART on

static uint32_t fake_moder = 0;                 // standing in for the real registers
static uint32_t fake_cr1 = 0;

int main() {
    Register<GpioModer> moder(fake_moder);
    Register<UsartCr1> cr1(fake_cr1);

    moder.write(Pin5Mode{}, 1);                 // 01: pin 5 is an output
    cr1.write(UsartEnable{}, 1);
    std::printf("MODER = 0x%08X, CR1 = 0x%08X\n", static_cast<unsigned>(moder.read()),
                static_cast<unsigned>(cr1.read()));

    moder.write(Pin5Mode{}, 7);                 // too big for 2 bits: only the field's bits change
    std::printf("after writing 7 into a 2-bit field: MODER = 0x%08X\n", static_cast<unsigned>(moder.read()));
    return 0;
}

// wrong_register.cpp - a USART field written into a GPIO register
#include <cstdint>

template <typename Reg, unsigned Shift, unsigned Width>
struct Field {
    static constexpr uint32_t mask = ((1u << Width) - 1u) << Shift;
};

template <typename Reg>
class Register {
public:
    explicit Register(volatile uint32_t &word) : word_(word) {}

    template <unsigned Shift, unsigned Width>
    void write(Field<Reg, Shift, Width>, uint32_t value) {
        constexpr uint32_t mask = Field<Reg, Shift, Width>::mask;
        word_ = (word_ & ~mask) | ((value << Shift) & mask);
    }

private:
    volatile uint32_t &word_;
};

struct GpioModer {};
struct UsartCr1 {};
using UsartEnable = Field<UsartCr1, 13, 1>;

void setup(volatile uint32_t &moder_word) {
    Register<GpioModer> moder(moder_word);
    moder.write(UsartEnable{}, 1);
}