1. Avoid Expensive Copies

// BAD: copies entire vector!
void process(vector<int> v);

// GOOD: just passes an address
void process(vector<int>* v);

A pointer is always 8 bytes. The data could be gigabytes.

2. Dynamic Data Structures

struct Node {
    int data;
    Node* next;  // → next node
};

Linked lists, trees, graphs — all built with pointers connecting nodes.

3. Polymorphism

Shape* s = new Circle();
s->draw();  // calls Circle::draw

s = new Square();
s->draw();  // calls Square::draw

Base pointer → derived object. Enables runtime flexibility.

Trap 1: Multiple Declarations

int* p, q;  // SURPRISE!
// p is int*
// q is just int (NOT a pointer!)

// Correct way:
int *p, *q;  // both pointers

The * binds to the variable name, not the type. Best practice: one declaration per line.

Trap 2: Style Wars

int* p;  // "pointer to int" style
int *p;  // "p is a pointer" style
int * p; // also valid

// All three are identical to the
// compiler! Pick one and be consistent.

We'll use int* p in this course (groups the * with the type).

Trap 3: const Pointer Combos

const int* p;      // can't change *p
int* const p = &x; // can't change p
const int* const p = &x;
                    // can't change either!

Read right-to-left: "p is a const pointer to const int"

Unknown Size at Compile Time

int n;
cin >> n;
// int arr[n]; ← NOT standard C++!
int* arr = new int[n]; // ✅

Stack arrays need compile-time constant sizes. Heap arrays can be any size.

Data Outlives the Function

int* create() {
    int* p = new int(42);
    return p; // ✅ survives!
}
// (can't return &localVar)

Heap data persists until you explicitly free it.

Very Large Allocations

// Stack: ~1-8 MB (crash!)
// int huge[10000000];

// Heap: GBs available
int* huge = new int[10000000]; // ✅

Stack overflow is a real thing! Large data belongs on the heap.

💀 Use After Delete

int* p = new int(42);
delete p;
cout << *p; // 💥 dangling!

Click to see explanation

🏚️ Return Local Address

int* bad() {
    int x = 10;
    return &x; // 💥
}

Click to see explanation

🔁 Double Free

int* p = new int(42);
delete p;
delete p; // 💥 double free!

Click to see explanation

~Destructor

~MyClass() {
    delete[] data;
}

Cleans up when object is destroyed

Copy Constructor

MyClass(const MyClass& o) {
    data = new int[o.size];
    copy(o.data, ...);
}

Deep copy, not shallow

Copy Assignment

MyClass& operator=(const MyClass& o) {
    if(this!=&o) { ... }
    return *this;
}

Handles a = b;

Memory

class Buffer {
    int* data;
public:
    Buffer(int n)
      : data(new int[n]) {}
    ~Buffer()
      { delete[] data; }
};

File Handles

class FileGuard {
    FILE* f;
public:
    FileGuard(const char* path)
      : f(fopen(path, "r")) {}
    ~FileGuard()
      { if(f) fclose(f); }
};

Mutex Locks

// std::lock_guard is RAII!
{
    lock_guard<mutex> lk(mtx);
    // critical section
} // auto-unlocks here

// No manual unlock needed
// Exception-safe too!

Factory Functions

unique_ptr<Shape> createShape(
    string type) {
  if (type == "circle")
    return make_unique<Circle>();
  return make_unique<Square>();
}
// Caller owns the result
auto s = createShape("circle");

Return unique_ptr from factories — ownership is clear and explicit.

In Containers

vector<unique_ptr<Shape>> shapes;

shapes.push_back(
    make_unique<Circle>(5));
shapes.push_back(
    make_unique<Square>(3));

// All auto-freed when vector dies
for (auto& s : shapes)
    s->draw();

Polymorphic collections without manual delete loops.

Custom Deleters

// For C APIs that need special cleanup
auto deleter = [](FILE* f) {
    fclose(f);
};
unique_ptr<FILE, decltype(deleter)>
    file(fopen("data.txt", "r"),
         deleter);
// fclose called automatically!

Wrap any C resource in RAII with a custom deleter.

Pointers Are Addresses

A pointer stores the memory address of another variable. Use & to get an address, * to follow it.

new/delete Manage Heap

new allocates, delete frees. Every new needs exactly one delete. Match new[] with delete[].

Top Bugs

Memory leaks (forgot delete), dangling pointers (use after delete), double free. All cause undefined behavior.

Smart Pointers Fix It

unique_ptr for single ownership, shared_ptr for shared. They auto-delete — no leaks, no dangling.

Q1: What does &x give you?

Q2: What is *p when p is a pointer?

Q3: What is nullptr?

A function needs to modify the caller's variable

A linked list node pointing to the next node

A texture shared by multiple game objects

A function that creates an object and returns it to the caller

Q1: What prints?

int x = 5;
int& r = x;
int* p = &r;
*p = 10;
cout << x << " " << r;

Q2: How many bytes leaked?

int* a = new int[10];
int* b = new int[5];
a = b;
delete[] a;

Q3: Is this code safe?

auto p = make_unique<int>(42);
auto q = move(p);
cout << *p;

Q4: What's wrong here?

void foo(unique_ptr<int> p) {
    cout << *p;
}
auto x = make_unique<int>(10);
foo(x);