1. Home
2. Academy
3. Embedded C++
4. Volume 00

0.1 Why C++ on a microcontroller

C++ keeps almost everything you know from C and adds ways for the compiler to check your code and do work for you. Used with care, that help costs nothing on the chip.

You may have written C++ already without knowing it. Every Arduino sketch is a C++ program: the setup() and loop() functions you write are compiled by a C++ compiler. Firmware teams in cars, medical devices and consumer products use it too, often under coding rules written for safety-critical C++, such as MISRA C++.

The easiest way to see what C++ adds is to write the same thing twice. Here is an LED, first the C way and then as a C++ class:

// same_led.cpp - the same LED, written the C way and the C++ way
#include <cstdint>
#include <cstdio>

// The C way: the data lives in a struct, and the functions that work on it
// take a pointer to it.
struct led_c {
    uint8_t pin;
    bool    on;
};

static void led_c_toggle(led_c *l) { l->on = !l->on; }

// The C++ way: the same data, with the function inside the type.
class Led {
public:
    explicit Led(uint8_t pin) : pin_(pin), on_(false) {}
    void toggle() { on_ = !on_; }
    bool is_on() const { return on_; }
    uint8_t pin() const { return pin_; }

private:
    uint8_t pin_;
    bool    on_;
};

int main() {
    led_c a = {5, false};
    Led   b(5);

    led_c_toggle(&a);
    b.toggle();

    std::printf("C struct:  %zu bytes, pin %u is %s\n", sizeof a,
                static_cast<unsigned>(a.pin), a.on ? "on" : "off");
    std::printf("C++ class: %zu bytes, pin %u is %s\n", sizeof b,
                static_cast<unsigned>(b.pin()), b.is_on() ? "on" : "off");
    return 0;
}

C struct:  2 bytes, pin 5 is on
C++ class: 2 bytes, pin 5 is on

Both take 2 bytes. The class is the struct with its functions moved inside it - nothing is added to the object in memory. What the class does add is a promise the compiler enforces: pin_ and on_ are private, so no other part of the program can change them by mistake. Every change has to go through toggle().

What C++ gives firmware

0.2 Myths and real costs

Most fears about C++ on small chips are myths. A few costs are real, and each one comes from a specific feature that you can avoid or switch off.

Four myths

The real costs, measured

These numbers were measured for this course with GCC 15.2 on a PC. A microcontroller build gives different numbers - its pointers are 4 bytes, not 8 - but the comparisons hold.

The exception numbers need a word of explanation. When an exception passes through a function, the program must still run the destructors of that function's local objects. To do that, the compiler stores unwind tables that describe every function's stack. Those tables are there whether or not anything is ever thrown.

0.3 The embedded C++ subset

The embedded C++ subset is C++ without the features that need a heap, exceptions or type information while the program runs. What is left is most of the language.

Here is a short program using several of the "use freely" features. It was built with exceptions and RTTI switched off, like every example in this course:

// subset.cpp - everyday embedded C++, built with -fno-exceptions -fno-rtti
#include <array>
#include <cstdint>
#include <cstdio>

namespace board {

enum class Colour : uint8_t { red, green, blue };

// Worked out by the compiler, not by the chip at run time.
constexpr uint32_t clock_hz = 16'000'000;
constexpr uint32_t uart_divisor(uint32_t baud) { return clock_hz / (16u * baud); }

}  // namespace board

static_assert(board::uart_divisor(9600) == 104, "check the divisor sum");

int main() {
    std::array<uint16_t, 4> readings = {512, 530, 498, 505};

    uint32_t total = 0;
    for (uint16_t r : readings) {
        total += r;
    }

    board::Colour c = board::Colour::green;

    std::printf("%zu readings, average %u\n", readings.size(),
                static_cast<unsigned>(total / readings.size()));
    std::printf("colour code %u\n", static_cast<unsigned>(c));
    std::printf("UART divisor for 9600 baud: %u\n", static_cast<unsigned>(board::uart_divisor(9600)));
    return 0;
}

4 readings, average 511
colour code 1
UART divisor for 9600 baud: 104

Four things are worth noticing:

• namespace board keeps clock_hz and uart_divisor out of the global names, so another file can have its own clock_hz without a clash.
• std::array knows its own size, so readings.size() is 4 without a separate constant to keep in step.
• uart_divisor(9600) is constexpr, so the compiler works it out while compiling.
• The static_assert checks that answer during the build. If someone changes the clock and the divisor stops being 104, the program will not compile at all.

0.4 Compiler flags: -fno-exceptions and -fno-rtti

Two compiler flags switch off the expensive features, and after that the compiler refuses any code that uses them - so the build itself proves they are gone.

-fno-exceptions

Compile this with -fno-exceptions:

// throw.cpp - throw, in a build made with -fno-exceptions
int read_sensor(int channel) {
    if (channel > 3) {
        throw channel;
    }
    return channel * 100;
}

throw.cpp: In function 'int read_sensor(int)':
throw.cpp:4:15: error: exception handling disabled, use '-fexceptions' to enable

The code does not compile, and that is the point. Nobody can add a throw to the firmware by accident, because the build fails the moment they try. Errors are reported in other ways instead - a return value, or an error code - which Volume 06 covers.

-fno-rtti

// dynamic_cast.cpp - dynamic_cast, in a build made with -fno-rtti
struct Sensor {
    virtual ~Sensor() = default;
    virtual int read() = 0;
};

struct Thermometer : Sensor {
    int read() override { return 25; }
};

int celsius(Sensor *s) {
    Thermometer *t = dynamic_cast<Thermometer *>(s);
    return t != nullptr ? t->read() : -1;
}

dynamic_cast.cpp: In function 'int celsius(Sensor*)':
dynamic_cast.cpp:12:22: error: 'dynamic_cast' not permitted with '-fno-rtti'

dynamic_cast asks, while the program runs, "is this sensor really a thermometer?" To answer, it needs the type information that -fno-rtti removes. Well-designed firmware rarely needs to ask: Volume 04 shows how to give the base class the functions callers need instead.

Other flags worth knowing

The third row is called garbage collection of sections. Without it, the linker keeps every function in a file if any one of them is used.

How to run the examples

Every example in this course was built with this command:

g++ -std=c++20 -Wall -Wextra -Werror -Wpedantic -Wshadow -Wconversion -Wsign-conversion \
    -Wold-style-cast -Wnon-virtual-dtor -Woverloaded-virtual \
    -fno-exceptions -fno-rtti -O1 -g example.cpp -o example

You do not need to install anything to follow along. Compiler Explorer, a free website, compiles C++ in your browser. It can also compile for ARM microcontrollers, so you can see the instructions a Cortex-M chip would run. If you prefer to work offline, g++ is free on Linux and macOS, and on Windows through WSL.

What you learned

• C++ keeps what you know from C and adds features the compiler checks and works out for you.
• A class with member functions takes the same memory as the equivalent struct.
• The real costs come from specific features: exceptions, RTTI, iostream, the heap and virtual functions.
• The embedded subset keeps most of the language and drops only what needs run-time support.
• -fno-exceptions and -fno-rtti switch those features off, and make any use of them a compile error.
• Unused code can be removed at link time with -ffunction-sections -fdata-sections -Wl,--gc-sections.

Key words from this volume

Every word below has a plain-English entry in the glossary.

• C++
• Class
• Object
• Namespace
• RAII
• Template
• constexpr
• enum class
• Heap
• Exception
• RTTI (run-time type information)
• iostream
• vtable
• Unwind table
• static_assert
• Compiler flag
• --gc-sections

Practice

Interview corner