CS106B - Programming Abstractions in C++

In pass-by-value, a copy of the argument is passed to the function, so modifications do not affect the original variable. In pass-by-reference (using &), the function receives an alias to the original object, allowing direct modification and avoiding costly copying of large structures.

A recursive function requires two core components:
1. Base Case: The simplest scenario that returns a result directly without further recursive calls, preventing stack overflow.
2. Recursive Step: Reduces the problem into smaller subproblems and calls the function on those subproblems, progressing toward the base case.

A systematic technique for searching a decision space using recursion through three core steps:
1. Choose: Make a tentative decision.
2. Explore: Recursively solve remaining subproblems based on that choice.
3. Unchoose: Undo the choice (backtrack) to restore state before attempting alternative choices.

Heap memory is allocated dynamically using new and must be freed manually using delete to prevent memory leaks:

int* ptr = new int(42); // Allocates an int on heap
delete ptr;             // Frees allocated heap memory
ptr = nullptr;          // Prevents dangling pointer

Dynamic arrays allocated on the heap using new[] must be deallocated using delete[] to ensure all elements are properly destroyed:

int* arr = new int[100]; // Allocates array of 100 ints
delete[] arr;            // Correctly frees array memory

Adding an integer $k$ to a pointer p advances its address by $k\times \text{sizeof}(T)$ bytes, where $T$ is the element type pointed to. For example, if p is an int* at address 0x1000, p + 1 points to 0x1004 (assuming 4-byte integers).