Pointers Memory-Tracing Exercises (10)

← Module home · The rule of this page: diagram first, verdict second, code never. You are not asked to write programs — you are asked to see them. Every answer includes the reference diagram drawn in the course style; check your arrow work against it.

Drawing style (same as the lessons): one box per variable, address above the box, value inside, arrows for pointers, dashed outline for heap boxes, and heap boxes drawn lower, separated from the stack.

   STACK                        HEAP
  ┌──────┐                    ╔══════╗
  │ 1000 │ p                 ║  42  ║  anonymous
  └──────┘                    ╚══════╝
      ↑___________________________|

Trace each snippet statement by statement — one diagram per state change — then commit to the answers. All solutions are in the answers section (separated so you can’t peek by accident).

T1 — Warm-up: names, values, addresses (★)

int x = 7;
int y = x;
y = 9;

Draw the state after each line (choose addresses: x at 1000, y at 1004). Answer: (a) after line 2, what is x? (b) which statement proved y was a copy, not an alias?

T2 — The alias (★)

int x = 7;
int& r = x;
r = 9;

Draw all three lines (draw r as a label, not a box — Lesson 2 §2). Answer: (a) after line 3, x = ? (b) how many boxes exist? (c) what does &r print?

T3 — The pointer twin (★)

int x = 7;
int* p = &x;
*p = 9;

Draw after each line. Answer: (a) how many boxes exist now (count p!) (b) after line 3, x = ? (c) name the one statement that would make p point at a new, different variable y.

T4 — Two jobs (★)

int a = 1, b = 2;
int* p = &a;
p = &b;
*p = 20;

Draw four diagrams — one per line. Answer: (a) which two lines changed the arrow, and which changed a box? (b) final a and b?

T5 — The dropped arrow (★★ — the leak, by eye)

int* p = new int(10);
p = new int(20);

Draw after line 1. Then draw after line 2 — and mark the orphan. Answer: (a) what happened to the first box? (b) name the family and the one-line fix (two acceptable fixes).

T6 — Swap, three ways (★★)

Version A: void swapV(int a, int b) — plain values, classic swap body. Version B: void swapR(int& a, int& b) — references. Version C: void swapP(int* a, int* b) — pointers, body uses *a/*b. Call each with swap?(x, y) / swapP(&x, &y) from main, x=1, y=2. Draw the moment of the first body line for each version (what boxes exist inside the callee?). Answer: (a) which version(s) affect main’s boxes, and by what mechanism? (b) for version A, what would x and y be after the call?

T7 — Reference vs pointer parameter (★★)

void refOn(int& r)  { r = r + 1; }
void ptrOn(int* p)  { *p = *p + 1; }

int main() {
    int n = 10;
    refOn(n);
    ptrOn(&n);
}

Draw both calls at their moment of execution (parameter boxes included; for ptrOn, draw p’s own stack box). Answer: (a) after both calls, n = ? (b) which callee has a box holding an address? (c) which callee cannot be called on a null target, ever, and why?

T8 — Array name and arithmetic (★★)

int arr[4] = {10, 20, 30, 40};
int* p = arr + 1;
std::cout << *p;      // ?
p = p + 2;
std::cout << *p;      // ?

Draw the array at 5000 (boxes 5000/5004/5008/5012), then p after each statement. Answer: (a) the two printed values (b) what does p - 1 point at after the last line? (c) what would *(p + 1) read after line 4 — and is that read safe?

T9 — The dynamic block (★★★)

int n = 3;
int* data = new int[n];
data[0] = 5;
data[1] = 6;
data[2] = 7;
int* cursor = data;
delete[] data;
data = nullptr;
// ...and the snippet stops. cursor is never touched again.

Draw at the peak (after line 6), and again after line 8. Answer: (a) at the peak, which stack boxes hold addresses? (b) after line 8, what does cursor hold — is it null? (c) name the exact latent bug this snippet ends with, its family, and the two-line repair.

T10 — The mystery snippet (★★★ — diagnose by eye)

A classmate wrote this and reports it “usually works”:

int* make() {
    int local = 99;
    return &local;
}

int main() {
    int* p = make();
    std::cout << *p << '\n';     // prints 99?! "works!"
}

Draw the stack at the moment make returns, and the moment after. Answer: (a) what does the returning do to local’s box, in diagram terms? (b) why does the print often show 99 anyway? (c) which family is this, which lesson section names it, and what are the two honest fixes? (d) why is “it printed 99” worthless as evidence?

Answers