Base CS from zero
Memory: multiple-choice review
Crux Multiple-choice synthesis across the memory unit: addresses vs values, byte-addressing, pointers and dereferencing, and stack vs heap lifetimes.
Your altitude — climbing toward senior
ZeroJuniorMiddleSenior
You are at middle altitude — in the skySix questions that pull the whole unit together. None of them is a definition to recite — each asks you to combine two or three ideas (address vs value, the byte, pointers, stack vs heap) and reason about what the machine actually does.
Goal
Confirm you can connect the unit’s core ideas: a cell has both an address and a value, the byte is the addressable unit, a value can itself be an address (a pointer), and the stack and heap are two regions of the same memory with different lifetimes.
Quiz
Completed
A cell at address 7 holds the value 7. Which statement is correct?
Heads-up There is nothing special about a cell whose address happens to equal its value. Address and value are independent — one names the location, the other is the data. Their being equal here is pure coincidence.
Heads-up A write changes only the value in the cell. The address is the cell's permanent position in the row and never changes when you overwrite the contents.
Heads-up A cell is a pointer only when the program intentionally uses its value as an address. A value equal to the cell's own address does not make it a self-pointer; nothing here treats the 7 as an address.
Quiz
Completed
A program stores a 32-bit integer in byte-addressed memory starting at address 100. Which addresses does it occupy, and why?
Heads-up Each address names exactly one byte (8 bits), not 32 bits. A 32-bit value needs four bytes, so it occupies four consecutive addresses; the CPU loads them together.
Heads-up Memory is byte-addressed, not bit-addressed. An address names a whole byte, so a 32-bit value uses 32 / 8 = 4 addresses, not 32.
Heads-up Two bytes hold only 16 bits. A 32-bit integer needs four bytes (four addresses). The byte count comes from bits divided by 8.
Quiz
Completed
Cell at address 5 holds value 12. Cell at address 12 holds value 99. A program dereferences the pointer at address 5. How many memory reads happen, and what is the final result?
Heads-up Dereferencing does not stop at the pointer cell. It uses the value found (12) as a second address and reads that cell too. The result is the value at address 12, which is 99.
Heads-up Dereferencing does not loop back. It reads the pointer (5 to get 12), then reads address 12 to get 99. The result is 99, not the starting address.
Heads-up The pointer value 12 is an address, not the data. You must perform a second read at address 12 to reach the actual value 99. Both reads are required.
Quiz
Completed
Why does indirection through a pointer appear in almost every non-trivial program, given that it costs an extra memory read?
Heads-up Indirection is slower for a single access — it adds a read. Pointers are used for sharing and flexible updates, not for raw speed of one lookup.
Heads-up The hardware can read any cell directly by its address. Pointers are a software convention layered on top, used when sharing or indirection is needed — not a hardware requirement.
Heads-up A pointer adds storage (the address-sized pointer plus the data it points to). The benefit is sharing and indirect updates, not smaller storage.
Quiz
Completed
Function main calls a, which calls b. While b is running, a creates a large object on the heap and keeps a pointer to it. b returns, then a returns. What is true about memory afterward?
Heads-up Heap data is not tied to a function's lifetime. Unlike a stack frame, it survives until explicitly freed or garbage collected — that independence from call lifetime is the whole point of the heap.
Heads-up The stack is LIFO: the most recently pushed frame (b's) is the first popped, when b returns. Frames never outlive the function they belong to.
Heads-up The stack and heap are regions of the same physical RAM. The object survives because of heap lifetime rules, not because it sits on different hardware.
Quiz
Completed
A recursive function with no base case keeps calling itself and the program crashes with a stack overflow. What actually happened, in terms of the unit's model?
Heads-up Stack overflow is about the stack region, not the heap. Each call pushes a frame onto the stack; with no base case, frames accumulate until the stack's fixed size is exceeded.
Heads-up The crash is the stack region exceeding its reserved size, not the machine running out of addresses. The address space is far larger than the stack's small fixed limit.
Heads-up Stack overflow is about the number of frames (depth of nesting), not the size of any single value. Unbounded recursion grows the frame count without bound.
Recap
The through-line of this unit is one model: memory is a row of byte-addressed cells; every cell has a fixed address and a changeable value; a value can itself be an address, which is what makes a pointer, and following it (dereferencing) costs one extra read; and the same physical memory is split into a LIFO stack whose frames live exactly as long as their function and a heap whose objects can outlive any call. Every question above resolves back to telling address from value, and lifetime from location.