Memory Allocation Internals

#include <iostream>
using namespace std;

int main() {
    // new does TWO things: grabs raw bytes, then runs the constructor.
    int* p = new int(42);          // allocate one int on the heap, set to 42
    cout << "Value: " << *p << endl;   // Value: 42   (*p reads through the pointer)
    delete p;                       // free it: bytes returned to the allocator
    p = nullptr;                    // good habit: avoid a dangling pointer

    // Arrays use new[] / delete[] -> they MUST match
...

#include <iostream>
#include <cstdlib>   // malloc, free
#include <new>       // placement new
using namespace std;

struct Point {
    int x, y;
    Point(int a, int b) : x(a), y(b) {        // constructor
        cout << "Point(" << x << "," << y << ") built" << endl;
    }
    ~Point() { cout << "Point destroyed" << endl; }
};

int main() {
    // malloc/free are C: they move BYTES and know nothing about objects.
    Point* a = (Point*) malloc(sizeof(Point)); // raw bytes only -> NO construct
...

#include <iostream>
using namespace std;

int main() {
    // 🎯 YOUR TURN — replace each ___ then press "Try it Yourself".

    // 1) Allocate ONE double on the heap, initialised to 3.14
    double* pi = ___;          // 👉 new double(3.14)

    cout << "pi = " << *pi << endl;

    // 2) Free that single double (single object -> plain delete)
    ___;                       // 👉 delete pi;

    // 3) Allocate an array of 4 ints, then free it with the matching delete
    int* scores = new int[4]
...

#include <iostream>
#include <new>   // for placement new
using namespace std;

struct Sensor {
    int id;
    double reading;
    Sensor(int i, double r) : id(i), reading(r) {
        cout << "Sensor " << id << " constructed" << endl;
    }
    ~Sensor() { cout << "Sensor " << id << " destroyed" << endl; }
};

int main() {
    // A raw byte buffer big enough for 2 Sensors, correctly aligned.
    alignas(Sensor) char buffer[sizeof(Sensor) * 2];

    // Placement new: build the object AT an addr
...

#include <iostream>
#include <new>
using namespace std;

struct Widget {
    int id;
    Widget(int i) : id(i) { cout << "Widget " << id << " built" << endl; }
    ~Widget() { cout << "Widget " << id << " gone" << endl; }
};

int main() {
    // 🎯 YOUR TURN — a buffer is ready; construct and destroy in it.
    alignas(Widget) char buffer[sizeof(Widget)];

    // 1) Construct a Widget with id 7 INSIDE buffer using placement new
    Widget* w = ___;          // 👉 new(buffer) Widget(7)

    cout 
...

#include <iostream>
#include <cstdlib>   // malloc, free
using namespace std;

// Override the GLOBAL operator new / delete to log every allocation.
// new(size) calls this; delete(ptr) calls operator delete below.
void* operator new(size_t size) {
    cout << "  [alloc " << size << " bytes]" << endl;
    void* p = malloc(size);          // get the raw bytes
    if (!p) throw bad_alloc();       // contract: throw on failure
    return p;
}
void operator delete(void* p) noexcept {
    cout << "  
...

#include <iostream>
#include <memory>   // std::allocator
using namespace std;

int main() {
    // std::allocator is the policy every STL container uses underneath.
    // It splits allocation (raw bytes) from construction (run constructor),
    // exactly like operator new + placement new, but as a reusable object.
    allocator<int> alloc;

    // 1) allocate raw, uninitialised space for 3 ints
    int* data = alloc.allocate(3);

    // 2) construct each value in place (this is placement new 
...

#include <iostream>
using namespace std;

// A pool pre-allocates fixed-size slots. allocate()/deallocate() just
// pop/push a free list: O(1), no system calls, no fragmentation.
template<typename T, size_t N = 8>
class Pool {
    union Slot { T value; Slot* next; };  // a slot is either a value OR a link
    Slot slots[N];
    Slot* freeList;
public:
    Pool() {
        freeList = &slots[0];                       // chain every slot together
        for (size_t i = 0; i < N - 1; i++) slots[i].
...