Memory Without the Heap

// static_local.cpp - a static local object is made on the first call, and kept
#include <cstdint>
#include <cstdio>

class Calibration {
public:
    Calibration() { std::printf("  Calibration constructed: reading the values from flash\n"); }
    int16_t offset() const { return -12; }
};

static const Calibration &calibration() {
    static Calibration c;               // made on the first call only
    return c;
}

int main() {
    std::printf("main starts\n");
    std::printf("first call:\n");
    int16_t a = calibration().offset();
    std::printf("second call:\n");
    int16_t b = calibration().offset();
    std::printf("offsets %d and %d\n", a, b);
    return 0;
}

// array.cpp - std::array: a C array that knows its size and can be copied
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstdio>

// A C array parameter is really a pointer: the size is lost on the way in.
static size_t count_c(const uint8_t *buffer, size_t length) {
    size_t zeros = 0;
    for (size_t i = 0; i < length; i++) {
        zeros += buffer[i] == 0 ? 1u : 0u;
    }
    return zeros;
}

// A std::array keeps its size as part of its type.
template <size_t N>
static size_t count(const std::array<uint8_t, N> &buffer) {
    size_t zeros = 0;
    for (uint8_t b : buffer) {
        zeros += b == 0 ? 1u : 0u;
    }
    return zeros;
}

int main() {
    uint8_t c_frame[8] = {1, 0, 2, 0, 3, 0, 4, 5};
    std::array<uint8_t, 8> frame = {1, 0, 2, 0, 3, 0, 4, 5};

    std::printf("C array: %zu zeros, and the length had to be passed separately\n", count_c(c_frame, 8));
    std::printf("std::array: %zu zeros, and frame.size() is %zu\n", count(frame), frame.size());
    std::printf("sizeof frame = %zu: no hidden extra data\n", sizeof frame);

    std::array<uint8_t, 8> copy = frame;        // a std::array can be copied with =
    copy[0] = 99;
    std::printf("after changing the copy: frame[0] = %u, copy[0] = %u\n", static_cast<unsigned>(frame[0]),
                static_cast<unsigned>(copy[0]));
    return 0;
}

// sizeof_param.cpp - the C mistake: sizeof on an array parameter
#include <cstddef>
#include <cstdint>

size_t frame_length(const uint8_t frame[8]) {
    return sizeof frame;
}

// get_bounds.cpp - std::get checks the index while compiling
#include <array>
#include <cstdint>

uint8_t fifth(const std::array<uint8_t, 4> &frame) {
    return std::get<4>(frame);
}

// fixed_vector.cpp - a vector with a fixed capacity: grows and shrinks, never allocates
#include <array>
#include <cstddef>
#include <cstdint>
#include <cstdio>

template <typename T, size_t Capacity>
class FixedVector {
public:
    bool push_back(const T &item) {
        if (count_ == Capacity) {
            return false;                   // full: the caller must deal with it
        }
        items_[count_] = item;
        count_++;
        return true;
    }
    void clear() { count_ = 0; }
    size_t size() const { return count_; }
    static constexpr size_t capacity() { return Capacity; }
    const T *begin() const { return items_.data(); }
    const T *end() const { return items_.data() + count_; }

private:
    std::array<T, Capacity> items_{};
    size_t count_ = 0;
};

struct Event {
    uint32_t time_ms;
    uint8_t code;
};

int main() {
    FixedVector<Event, 3> log;
    for (uint8_t code = 1; code <= 4; code++) {
        bool ok = log.push_back(Event{code * 100u, code});
        std::printf("push event %u: %s\n", static_cast<unsigned>(code), ok ? "stored" : "no room");
    }
    for (const Event &e : log) {
        std::printf("event %u at %u ms\n", static_cast<unsigned>(e.code), static_cast<unsigned>(e.time_ms));
    }
    std::printf("%zu of %zu used, and the whole log is %zu bytes, fixed while compiling\n", log.size(),
                log.capacity(), sizeof log);
    return 0;
}

// placement_new.cpp - making an object later, in memory set aside at compile time
#include <cstdint>
#include <cstdio>
#include <new>

class Uart {
public:
    explicit Uart(uint32_t baud) : baud_(baud) { std::printf("Uart constructed at %u baud\n", static_cast<unsigned>(baud_)); }
    ~Uart() { std::printf("Uart destroyed\n"); }
    uint32_t baud() const { return baud_; }

private:
    uint32_t baud_;
};

// Room for one Uart, correctly aligned, reserved while compiling. Nothing is constructed yet.
alignas(Uart) static unsigned char uart_storage[sizeof(Uart)];
static Uart *console = nullptr;

static uint32_t read_baud_from_settings() { return 57600; }     // standing in for flash or EEPROM

int main() {
    std::printf("start-up: clocks and settings are not ready yet\n");
    uint32_t baud = read_baud_from_settings();

    console = new (uart_storage) Uart(baud);            // placement new: construct it here, now
    std::printf("console runs at %u baud, stored inside uart_storage: %s\n",
                static_cast<unsigned>(console->baud()),
                static_cast<void *>(console) == static_cast<void *>(uart_storage) ? "yes" : "no");

    console->~Uart();                                   // the destructor must be called by hand
    console = nullptr;
    return 0;
}

// status.cpp - reporting errors without exceptions
#include <cstdint>
#include <cstdio>

// Every way a reading can go wrong, as a named value. (enum class is covered in Volume 07.)
enum class Status : uint8_t { ok, timeout, bad_checksum };

static const char *text(Status s) {
    switch (s) {
    case Status::ok:
        return "ok";
    case Status::timeout:
        return "timeout";
    case Status::bad_checksum:
        return "bad checksum";
    }
    return "unknown";
}

// The answer goes out through a reference; the return value says whether it can be trusted.
static Status read_temperature(bool sensor_answers, bool checksum_good, int16_t &celsius) {
    if (!sensor_answers) {
        return Status::timeout;
    }
    if (!checksum_good) {
        return Status::bad_checksum;
    }
    celsius = 25;
    return Status::ok;
}

int main() {
    int16_t celsius = 0;
    Status s = read_temperature(true, true, celsius);
    std::printf("good sensor:   %s, %d C\n", text(s), celsius);
    s = read_temperature(false, true, celsius);
    std::printf("no answer:     %s\n", text(s));
    s = read_temperature(true, false, celsius);
    std::printf("damaged frame: %s\n", text(s));
    return 0;
}

// kind.cpp - asking "what kind of sensor?" without RTTI
#include <cstdint>
#include <cstdio>

enum class SensorKind : uint8_t { thermometer, barometer };

class Sensor {
public:
    virtual ~Sensor() = default;
    virtual SensorKind kind() const = 0;    // the class answers for itself: no RTTI needed
    virtual int read() const = 0;
};

class Thermometer : public Sensor {
public:
    SensorKind kind() const override { return SensorKind::thermometer; }
    int read() const override { return 25; }
};

class Barometer : public Sensor {
public:
    SensorKind kind() const override { return SensorKind::barometer; }
    int read() const override { return 1013; }
};

int main() {
    Thermometer t;
    Barometer b;
    const Sensor *sensors[] = {&t, &b};
    for (const Sensor *s : sensors) {
        if (s->kind() == SensorKind::thermometer) {
            std::printf("a thermometer, reading %d C\n", s->read());
        } else {
            std::printf("not a thermometer, reading %d\n", s->read());
        }
    }
    return 0;
}

// init_order.cpp - a global object that uses a global from another file
#include <cstdint>
#include <cstdio>

extern uint32_t configured_baud;        // defined in init_order_part1.cpp

class Uart {
public:
    explicit Uart(uint32_t baud) : baud_(baud) { std::printf("Uart constructed at %u baud\n", static_cast<unsigned>(baud_)); }
    uint32_t baud() const { return baud_; }

private:
    uint32_t baud_;
};

Uart console(configured_baud);          // which is set up first: this, or configured_baud?

int main() {
    std::printf("in main: configured_baud = %u, console runs at %u baud\n",
                static_cast<unsigned>(configured_baud), static_cast<unsigned>(console.baud()));
    return 0;
}

// init_order_part1.cpp - the other file: a global set up by calling a function
#include <cstdint>
#include <cstdio>

static uint32_t choose_baud() {         // not constexpr, so it runs at start-up
    std::printf("choose_baud() runs\n");
    return 115200;
}

uint32_t configured_baud = choose_baud();

// first_use.cpp - the fix: set the value up the first time it is asked for
#include <cstdint>
#include <cstdio>

extern uint32_t &configured_baud();     // defined in first_use_part1.cpp

class Uart {
public:
    explicit Uart(uint32_t baud) : baud_(baud) { std::printf("Uart constructed at %u baud\n", static_cast<unsigned>(baud_)); }
    uint32_t baud() const { return baud_; }

private:
    uint32_t baud_;
};

Uart console(configured_baud());        // asking for the value makes sure it is ready

int main() {
    std::printf("in main: console runs at %u baud\n", static_cast<unsigned>(console.baud()));
    return 0;
}

// first_use_part1.cpp - the value lives inside a function, and is set up on the first call
#include <cstdint>
#include <cstdio>

static uint32_t choose_baud() {
    std::printf("choose_baud() runs\n");
    return 115200;
}

uint32_t &configured_baud() {
    static uint32_t baud = choose_baud();   // runs on the first call, and only then
    return baud;
}

// constinit.cpp - constinit refuses a value that would need code at start-up
#include <cstdint>

uint32_t choose_baud();

constinit uint32_t fixed_baud = 115200;             // fine: a constant, stored ready in the program
constinit uint32_t configured_baud = choose_baud(); // refused: this would run at start-up