C++ Memory Management

Stack vs Heap

#include <iostream>
using namespace std;

int main() {
    // Stack allocation — automatic
    int stackVar = 42;

    // Heap allocation — manual
    int* heapVar = new int(42);
    cout << *heapVar << endl;
    delete heapVar;   // must free!
    heapVar = nullptr;

    // Heap array
    int* arr = new int[10];
    for (int i = 0; i < 10; i++) arr[i] = i * 2;
    delete[] arr;   // use delete[] for arrays!
    return 0;
}

RAII — Resource Acquisition Is Initialization

The best memory management pattern: acquire resources in constructors, release in destructors. Smart pointers implement RAII automatically.

class FileHandle {
  private:
    FILE* file;
  public:
    FileHandle(const char* path) { file = fopen(path, "r"); }
    ~FileHandle()                { if (file) fclose(file); }  // auto-close!
    FILE* get()                  { return file; }
};

Detecting Memory Leaks

// Leak — every new needs a matching delete
int* p = new int(5);
// forgot: delete p;  <-- leak!

// Fix: use smart pointers
auto p = make_unique<int>(5);
// auto-freed when p goes out of scope

Tools: Valgrind (Linux/macOS), AddressSanitizer (-fsanitize=address), Visual Studio Diagnostic Tools.

#include <iostream>
using namespace std;

class MemoryBlock {
  private:
    int* data;
    int  size;
  public:
    MemoryBlock(int n) : size(n), data(new int[n]) { cout << "Allocated\n"; }
    ~MemoryBlock() { delete[] data; cout << "Freed\n"; }
    int& operator[](int i) { return data[i]; }
    int  getSize() { return size; }
};

int main() {
    MemoryBlock block(5);
    for (int i = 0; i < block.getSize(); i++) block[i] = i * 10;
    for (int i = 0; i < block.getSize(); i++) cout << block[i] << " ";
    cout << endl;
    return 0;
}

Summary

• Stack is fast and automatic; heap is flexible but must be managed.
• Always pair new with delete, and new[] with delete[].
• RAII wraps resources in objects with constructors/destructors.
• Prefer smart pointers to eliminate memory leaks entirely.