8.06 Pointer-to-Pointer (Drone**) Fleet Arrays vs Flat Contiguous Array-of-Structures (AoS)

1. Pointer-to-Pointer Mechanics (Type**)

A pointer-to-pointer stores the memory address of another pointer. In classical C++, dynamic 2D tables or arrays of polymorphic objects are created by allocating an array of pointers (Drone** fleet = new Drone*[N]) and then individually allocating each object (fleet[i] = new Drone(...)).

2. Double Allocation Overhead

Managing $N$ objects requires $N + 1$ distinct heap allocations ($1$ array of pointers $+ N$ individual objects) and $N + 1$ corresponding delete calls.

1. The Hardware Cost of Pointer Chasing

Accessing fleet[i]->getBatteryLife() requires double dereferencing:

1. Read the pointer from the pointer array: ptr = *(fleet + i).
2. Dereference ptr to read the object in distant heap memory: ptr->battery.

Because each object was allocated separately on the heap, they are scattered randomly across SRAM. On modern pipelined microcontrollers (ARM Cortex-M7 with L1 data cache), this causes frequent cache misses and memory stall cycles.

2. Flat Contiguous Storage: Array of Structures (AoS)

Storing objects contiguously in a single flat array (std::array<Drone, MaxDrones>) requires zero pointer storage (saving $4 \times N$ bytes of RAM) and maximizes CPU spatial cache locality.

Here is an embedded fleet manager using flat contiguous memory with zero pointer indirection:

#include <cstdint>
#include <string_view>
#include <array>

struct DroneTelemetry {
    char     model_name[16];
    uint16_t battery_milli_volts; // e.g. 3700 mV
    uint8_t  active_status;
};

template <size_t MaxFleetSize>
class FlatDroneFleet {
private:
    // Contiguous in SRAM; 100% spatial cache locality; 0 pointer overhead
    std::array<DroneTelemetry, MaxFleetSize> drones_{};
    size_t active_count_{0};

public:
    bool register_drone(std::string_view model, uint16_t battery_mv) noexcept {
        if (active_count_ >= MaxFleetSize) return false;
        
        DroneTelemetry& d = drones_[active_count_++];
        size_t len = model.size() < 15 ? model.size() : 15;
        for (size_t i = 0; i < len; ++i) d.model_name[i] = model[i];
        d.model_name[len] = '\0';
        d.battery_milli_volts = battery_mv;
        d.active_status = 1;
        return true;
    }

    const DroneTelemetry* data() const noexcept { return drones_.data(); }
    size_t count() const noexcept { return active_count_; }
};