8.04 Arrow Operator (->) vs Dereference Dot (*ptr). & Zero-Heap Object Placement

1. Arrow Operator Syntax Sugar

The arrow operator (ptr->member) is syntactically equivalent to dereferencing the pointer and accessing the member via the dot operator: (*ptr).member. Parentheses are required around *ptr because the dot operator (.) has higher operator precedence than the dereference operator (*).

2. Heap Object Lifecycles

Objects allocated on the heap exist until explicitly deleted. Failing to call delete produces a memory leak that permanently consumes SRAM until the microcontroller is reset.

1. Placement-New for Deterministic Object Construction

Placement-new constructs an object at a specific, pre-allocated memory address without calling the heap allocator (malloc). In embedded systems, this allows creating objects in:

• Fast tightly-coupled SRAM (DTCM).
• Battery-backed backup SRAM.
• Pre-allocated static object pools with zero heap fragmentation.

2. Memory Alignment (alignas)

Microcontrollers require objects to be aligned to their natural boundaries (e.g. 32-bit integers at 4-byte aligned addresses). Unaligned access causes hardware UsageFaults on ARM Cortex-M processors when unaligned trapping is active.

Here is an embedded object pool utilizing placement-new for zero-heap, deterministic object creation:

#include <cstdint>
#include <cstddef>
#include <new>

template <typename T, size_t MaxCount>
class StaticObjectPool {
private:
    alignas(alignof(T)) std::byte storage_[MaxCount][sizeof(T)];
    bool in_use_[MaxCount]{false};

public:
    template <typename... Args>
    T* allocate(Args&&... args) noexcept {
        for (size_t i = 0; i < MaxCount; ++i) {
            if (!in_use_[i]) {
                in_use_[i] = true;
                return new (storage_[i]) T(std::forward<Args>(args)...);
            }
        }
        return nullptr; // Pool exhausted (no heap fallback)
    }

    void free(T* ptr) noexcept {
        if (!ptr) return;
        for (size_t i = 0; i < MaxCount; ++i) {
            if (reinterpret_cast<T*>(storage_[i]) == ptr) {
                ptr->~T(); // Explicit destructor call
                in_use_[i] = false;
                return;
            }
        }
    }
};