Placement New (Static Allocation Constructor)

Standard new allocates memory on the Heap and then constructs the object.

Placement New separates these steps. It allows you to construct an object in a pre-allocated memory buffer (Stack, Static, or a specific hardware address) that you explicitly provide.

This is the standard way to use C++ objects in strict embedded systems where the Heap is banned.

Syntax & Usage

1. Basic Setup

You need a memory buffer (usually a byte array) large enough to hold the object.

Note: You must include <new> to use this.

#include <new> 

class Sensor {
public:
    int id;
    Sensor(int i) : id(i) { printf("Init\n"); }
    ~Sensor() { printf("De-init\n"); }
};

// 1. Allocate raw memory (Static buffer)
// 'alignas' prevents bus faults by ensuring correct memory alignment
alignas(Sensor) uint8_t buffer[sizeof(Sensor)];

int main() {
    // 2. Use Placement New
    // Syntax: new (address) Type(args);
    Sensor* s = new (buffer) Sensor(10); 

    // s->id is now 10, stored inside 'buffer'
}

2. Manual Destruction

Because you didn't allocate memory with standard new, you cannot use standard delete. You must call the destructor manually.

// ❌ delete s;      // CRASH! Tries to free static memory to the heap manager.
s->~Sensor();        // ✅ Correct: Cleans up the object, leaves memory alone.

Memory Visualization

Standard new finds a random spot in the Heap. Placement new puts the object exactly where you say.

Relevance in Embedded/Firmware

1. No Heap Required

You can have full C++ objects (with constructors, v-tables, and inheritance) stored entirely in Static Memory (.bss). This makes your firmware deterministic and fragmentation-free, satisfying safety standards (MISRA, ISO26262).

2. Memory-Mapped Objects

You can place an object directly onto a hardware register or a specific memory region (e.g., backup SRAM or shared memory between cores).

// Construct a Driver object exactly at the hardware address 0x40005000
UART_Driver* uart1 = new (reinterpret_cast<void*>(0x40005000)) UART_Driver();

3. Object Pools

If you need to create/destroy objects frequently (e.g., Network Packets), use a pre-allocated array of buffers (a Pool). Use placement new to construct a packet in slot 0, manually destroy it, and then reuse slot 0 for a new packet later.

Common Pitfalls (Practical Tips)