CS50x: Introduction to Computer Science Memory Syllabus

Memory syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Memory in CS50x: Introduction to Computer Science, not a summary of it.

1. 1

   Pointers and Addresses

   3 topics

   • Hexadecimal
   • Pointers and Dereferencing
   • Segmentation Faults
2. 2

   Dynamic Memory

   4 topics

   • Stack and Heap
   • Dynamic Memory Allocation
   • Call Stacks
   • Buffer Overflow
3. 3

   Custom Types and Files

   3 topics

   • Defining Custom Types
   • File I/O and File Pointers
   • Working with Images
4. 4

   Debugging Memory

   2 topics

   • Valgrind
   • Memory Leaks

Memory flashcards for CS50x: Introduction to Computer Science

20 of 50 cards from the Memory deck — real questions with worked answers.

1. What is the hexadecimal (base-16) number system and which symbols does it use?

   A positional number system with base $16$. It uses sixteen symbols: the digits $0$–$9$ for values zero through nine and the letters A–F for values $10$ through $15$.

2. Why is hexadecimal convenient for representing computer memory and addresses?

   Because $16 = 2^{4}$, one hex digit maps exactly to $4$ bits, so one byte ($8$ bits) is exactly two hex digits. This makes binary data far more compact and readable than base-2.

3. What does the prefix 0x mean in a value like 0xFF in C?

   It signals that the number is written in hexadecimal (base $16$), distinguishing it from decimal. It has no effect on the value itself; $\text{0xFF} = 255$ in decimal.

4. Convert the decimal number $255$ to hexadecimal, showing the place values.

   $$255 = 15 \times 16^{1} + 15 \times 16^{0} = \text{0xFF}$$ since each hex digit position represents a power of $16$.

5. What is the general formula for the decimal value of a hexadecimal number with digits $d_{n} d_{n-1} \dots d_{0}$?

   $$\text{value} = \sum_{i=0}^{n} d_{i} \times 16^{i}$$ where each digit $d_{i}$ is between $0$ and $15$ (A–F standing for $10$–$15$).

6. What is a pointer in C?

   A variable that stores a memory address — typically the address of another variable. On a modern 64-bit system a pointer occupies $8$ bytes.

7. What does the & (address-of) operator do in C?

   Applied to a variable, it yields that variable's memory address. Example: if int n = 50;, then &n is the address in memory where n is stored.

8. What does the * (dereference) operator do when applied to a pointer?

   It 'goes to' the address stored in the pointer and accesses the value there. If int *p = &n;, then *p reads (or writes) the value of n.

9. What does the declaration int *p; mean, and what is the role of * in the declaration versus in an expression?

   It declares p as a pointer to an int. In a declaration, * marks the variable as a pointer type; in an expression, *p dereferences the pointer to access the pointed-to value.

10. What is a NULL pointer and why should you initialize pointers you don't yet have an address for to NULL?

    NULL is a special value meaning the pointer points to nothing. Initializing to NULL prevents the pointer from holding a garbage address, and lets you safely test if (p == NULL) before dereferencing.

11. What is a segmentation fault?

    A runtime error that occurs when a program tries to access a 'segment' of memory it isn't allowed to touch — e.g., reading or writing outside its permitted address space. The operating system terminates the program.

12. Name three common causes of segmentation faults in C.

    (1) Dereferencing a NULL or uninitialized (garbage) pointer, (2) accessing an array out of bounds, and (3) using memory after it has been freed (use-after-free).

13. What typically happens if you dereference a NULL pointer, and why is that behavior actually useful?

    The program crashes with a segmentation fault. This is useful because it fails immediately and predictably, rather than silently corrupting some unknown region of memory.

14. What is the stack region of a program's memory used for?

    It stores local variables and function call frames. Memory on the stack is managed automatically: it is allocated when a function is called and reclaimed when the function returns.

15. What is the heap region of a program's memory used for?

    It is the pool of memory for dynamic allocation via malloc (and friends). Heap memory persists until the programmer explicitly releases it with free — it is managed manually.

16. In the classic memory layout diagram, how are machine code, globals, heap, and stack arranged, and in which directions do the heap and stack grow?

    From top: machine code, then global variables, then the heap, with the stack at the bottom. The heap grows downward and the stack grows upward, toward each other — so they can collide if either grows too large.

17. Compare stack allocation and heap allocation with respect to management, lifetime, and speed.

    Stack: automatic management, lifetime tied to the function's scope, very fast. Heap: manual management (malloc/free), lifetime lasts until explicitly freed, slower and vulnerable to leaks if free is forgotten.

18. What is a stack overflow, and what commonly causes one?

    When the stack grows beyond its allowed space and overruns other memory — most commonly caused by infinite (or extremely deep) recursion, or by very large local arrays.

19. What is the purpose and behavior of malloc in C?

    malloc(size) dynamically allocates size bytes on the heap and returns a pointer (void *) to the first byte. The memory is uninitialized (contains garbage), and malloc returns NULL if allocation fails.

20. What are the three key rules for using free correctly?

    (1) Only free memory that was obtained from malloc/calloc/realloc, (2) free each block exactly once (no double free), and (3) never access memory after it has been freed.

See more Memory flashcards →

Planning Memory for CS50x: Introduction to Computer Science

Memory (CS50x: Introduction to Computer Science) FAQ