Embedded C++ Interview Vault

"The same machine code for the same work, with more checking. Classes keep data private, references cannot be null, RAII releases resources on every path, templates and constexpr move work to compile time, and enum class stops type mix-ups. I switch off exceptions and RTTI and avoid the heap, so the program stays small and predictable."

"A reference is another name for an existing variable: set once, never null, never moved, used without *. A pointer is a variable holding an address: it can be null, changed and used for arithmetic. Compiled, a reference parameter is passed as an address, so the machine code is the same."

"It gives a function its plain C name instead of a mangled C++ one. Firmware needs it for interrupt handlers, which the vector table finds by name, and for code shared with C. A handler without it links cleanly and never runs, because the weak default handler keeps the plain name."

"NULL is an integer zero underneath, so it can pick an int overload or be ambiguous. The keyword nullptr has its own type, which becomes any pointer and never a number."

"When the exact type matters. Adding two uint8_t values with auto gives an int holding 300, not a byte that wraps to 44. For register values, protocol fields and anything whose width matters, I write the type."

"A C cast can do any conversion without saying which. The C++ casts each do one kind, so the compiler refuses the wrong kind and reviewers can search for the risky ones. They compile to the same code - I measured the same 13 bytes as a C cast."

"Only the starting access: public for struct, private for class. I use struct for plain data and class for a type with rules to keep."

"The object's address is passed as a hidden argument called this. A member function compiles like a C function taking a struct pointer - the same 5 bytes in the course's test."

"It promises not to change the object, the compiler enforces it, and only const functions can be called through a const reference or on a const object."

"It cannot, so I design around it. I can make the object harmless when its arguments are bad, or split construction from an init() that returns a status. Or I can use a factory that returns an optional."

"Taking a resource in a constructor and giving it back in the destructor, so every path out of a scope releases it. I use it for interrupt locks, chip selects, bus locks and peripheral clocks."

"Save PRIMASK and disable interrupts in the constructor, write the saved value back in the destructor, and delete the copy functions. It must restore rather than enable, because critical sections nest."

"If a class needs its own destructor, it needs a decision about copying - that is three. Moves add two more - five. Best of all is zero: build classes from members that already behave correctly, and write none."

"A hidden pointer per object, a vtable per class in flash, and an indirect call that cannot be inlined unless the compiler can prove the type. I measured an 8-byte pointer on a PC and a 40-byte vtable for a small class."

"If an object is destroyed through a pointer to its base, a non-virtual destructor skips the derived part's clean-up, which is undefined behaviour. The -Wnon-virtual-dtor warning enforces it."

"A function that looks like a replacement but does not match - a missing const, say. With override, that is a build error instead of a silent second function."

"The base-class version runs. While the base part is being built, the object is only a base object, so the derived override is not yet reachable."

"A class inheriting from a template of itself, so the base can call the derived class directly. It shares code without a vtable or hidden pointer, and every call can be inlined. The cost is no common base type."

"Usually by redesigning, so the base class offers the function the caller needs. When the kind really must be asked, a virtual function returning an enum class does it at the cost of one vtable entry."

"They cost one copy per type used, the same as writing those functions by hand. The risk is a big template used with many types; I keep templates small and move type-independent code out of them."

"A const value cannot change once set, but may be set while running. A constexpr one can be worked out while compiling, and a consteval function must be. A constexpr table lands in flash with no RAM or start-up code."

"Register layouts against the datasheet, template parameters such as power-of-two sizes, and calculations such as baud-rate error - all for free, on every build."

"Static storage and the stack only: std::array, fixed-capacity containers, placement new or std::optional for objects built later, and status values instead of exceptions. The map file shows every byte."

"Globals that need start-up code are set up file by file in no fixed order, so one can read another while it is still zero. Use constinit or constexpr for shared globals, or a function with a static local."

"A guard variable, and by default calls that make its first-time construction thread-safe. The course measured 131 bytes of text, 90 with -fno-threadsafe-statics - which is only safe if nothing can call it concurrently."

"Scoped names, no quiet conversion to int, and a chosen size. With -Wall, a switch that misses a value is flagged, so adding a state finds every switch to update."

"It is 32 bytes, and it calls operator new when the callable does not fit inside it. A template parameter or a plain function pointer costs nothing, and a lambda that captures nothing fits a C callback."

"optional when the only failure is 'no value'. A status when there are several failures to tell apart, such as timeout and bad checksum. Either way, mark it nodiscard."

"Layers, with registers only in the lowest. Classes are handed their hardware through their constructors, and a board file wires the real objects. Tests wire fakes, so logic runs on a PC."

"The write function copies bytes into a ring buffer inside a critical section, and enables the TXE interrupt. Each TXE interrupt moves one byte to the data register. When the buffer is empty the handler disables TXE, or it fires for ever. And the write function must enable the interrupt even when the buffer fills part-way."

x = 12

Both references name x, so the first line makes it 2 and the second makes it 12. Functions that take two references and assume they are different are a classic source of this surprise.

driver base made
buffer made
uart driver made
uart driver gone
buffer gone
driver base gone

The base part first, then the members, then the class's own constructor body. Destruction runs in exactly the reverse order.

while constructing: Sensor
afterwards: Thermometer

While Sensor's constructor runs, the Thermometer part does not exist yet, so the virtual call goes to Sensor::name. Afterwards the same call reaches the override. Never rely on a derived class's behaviour from a base constructor.

101 102 103

The static local is set to 100 once, on the first call, and keeps its value between calls. The three calls are on separate lines on purpose: inside one printf, the order the arguments are worked out in is not fixed.

Plain 1, WithFunction 1, WithStatic 1, WithVirtual 16

Member functions and static members are not stored in objects, so the first three are all 1 byte. The virtual destructor adds the hidden vtable pointer - 8 bytes on this PC - and padding rounds the object up to 16.

drill_capture.cpp: In lambda function:
drill_capture.cpp:4:43: error: assignment of read-only variable 'presses'

A capture by value is a copy, and a lambda's copies are read-only unless it is marked mutable. Even if it were, it would change the copy, and count_presses would still return 0. The fix is to capture by reference: [&presses].