Arrays, Strings & Functions

int scores[] = {85, 92, 78, 95, 88};
int size = sizeof(scores) / sizeof(scores[0]);
// size is 5 — total bytes divided by one element's byte size

This pattern — total size divided by one element's size — is the classic C-style way to compute an array's length. Phase 7's STL introduces std::vector, which tracks its own size directly and avoids needing this pattern at all — but you'll still see this technique in real C++ code, so it's worth recognizing.

int board[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
std::cout << board[1][2];  // prints 6 — row 1, column 2

Think of a tic-tac-toe board, a chessboard, or a spreadsheet — board[row][col] reads directly as "the value at this row, this column," exactly matching how you'd describe a grid position out loud.

for (int row = 0; row < 3; row++) {
    for (int col = 0; col < 3; col++) {
        std::cout << board[row][col] << " ";
    }
    std::cout << std::endl;
}

This is exactly Phase 2 Module 4's nested-loop pattern, now genuinely put to work — walking through every cell of a real 2D grid, row by row.

Conceptually, "Hello" is a sequence of individual char values — 'H', 'e', 'l', 'l', 'o' — stored in order. std::string wraps this idea in a convenient, safe package that manages its own size automatically, unlike a raw array which has a fixed size you must track yourself.

std::string name = "Alex";
std::cout << name[0];        // prints 'A'
std::cout << name.length();  // prints 4

Strings are zero-indexed exactly like arrays (Module 1) — name[0] is the first character. .length() gives you the string's current size, always accurate, without needing the manual sizeof trick from Module 2.

std::string firstName = "Alex";
std::string lastName = "Rivera";
std::string fullName = firstName + " " + lastName;
// fullName is "Alex Rivera"

+ concatenates (joins) strings together — this is a genuine, different meaning of + than the arithmetic addition from Phase 1, and C++ figures out which one you mean based on the types involved.

std::string sentence = "The quick fox";
if (sentence.find("fox") != std::string::npos) {
    std::cout << "Found it!" << std::endl;
}

std::string::npos is the special value .find() returns when the text isn't found at all — always compare against it explicitly, rather than assuming any returned value means success.

C++ doesn't have a single built-in "make this uppercase" string method — instead, you loop through each character and convert it individually with the toupper()/tolower() functions:

std::string text = "hello";
for (int i = 0; i < text.length(); i++) {
    text[i] = toupper(text[i]);
}
// text is now "HELLO"

void printWelcome(std::string name) {
    std::cout << "Welcome, " << name << "!" << std::endl;
    // no return statement needed
}

Some functions just DO something (print a message, update the screen) without handing back a specific value — void as the return type says exactly that.

void doubleIt(int num) {
    num = num * 2;  // only changes the local copy
}

int main() {
    int x = 5;
    doubleIt(x);
    std::cout << x;  // still prints 5 — the original x is unchanged!
}

By default, C++ passes a COPY of the argument into a function — changes made inside the function affect only that local copy, never the original variable back in main().

void doubleIt(int& num) {  // note the &
    num = num * 2;
}

int main() {
    int x = 5;
    doubleIt(x);
    std::cout << x;  // prints 10 — the original x actually changed!
}

Adding & after the type in a parameter makes it a reference — the function now works with the ORIGINAL variable directly, not a copy. This is exactly how a function can meaningfully modify a caller's variable.

int add(int a, int b) {
    return a + b;
}

double add(double a, double b) {
    return a + b;
}

int main() {
    std::cout << add(2, 3);        // calls the int version → 5
    std::cout << add(2.5, 3.5);    // calls the double version → 6.0
}

C++ picks which version to actually run based on the TYPES of arguments you pass in — this is called overloading. It exists so that conceptually-related operations (like "add two things") can share one intuitive name, instead of needing awkward separate names like addInts and addDoubles.

Overloaded functions must differ in their PARAMETER TYPES or COUNT — not just their return type alone. Two functions with the same name and same exact parameter types, differing only in return type, is a compiler error, since C++ wouldn't be able to tell them apart from the calling code alone.

int factorial(int n) {
    if (n <= 1) {
        return 1;          // base case — stops the recursion
    }
    return n * factorial(n - 1);  // recursive case
}

factorial(5) is 5 × 4 × 3 × 2 × 1. Notice the function calls ITSELF with a smaller number each time — factorial(5) calls factorial(4), which calls factorial(3), and so on, until it hits the base case.

The base case (if (n <= 1) return 1; above) is the condition that stops the recursion. Without one, a recursive function calls itself forever — this is genuinely the exact same infinite-loop danger from Phase 2, just in recursive form instead of a while loop.

Everything recursion does, a loop can also do — and vice versa. Recursion tends to read more naturally for problems that are themselves naturally recursive (like navigating a tree-shaped folder structure), while loops are usually clearer and more efficient for simple repeated counting. You'll develop a feel for which fits better with experience.

Ask the user for a sentence, then report: the total character count, the number of vowels, and the sentence converted to uppercase — using separate, well-named functions for each job.

• countVowels passes by VALUE (Module 7) since it only needs to read the sentence, never modify it.
• toUppercase deliberately passes by REFERENCE, since modifying the original string in place is exactly the point — the whole reason to choose &.
• Each job (counting, converting) lives in its own clearly-named function, exactly the Pre-Course's "named instructions" idea, now genuinely doing real work.