C++ Fundamentals

Every type reserves a specific amount of memory. An int typically uses 4 bytes, giving it a fixed range it can represent (roughly -2 billion to +2 billion). If a calculation produces a number outside that range, it overflows — silently wrapping around to an incorrect value, without any error or warning. This is exactly why C++ offers multiple whole-number types (short, int, long, long long) of different sizes — you pick based on the range of values you actually need.

Variable names must start with a letter or underscore, can contain letters/numbers/underscores, and are case-sensitive (score and Score are two different variables). The convention in C++ is camelCase for variable names — totalScore, not total_score or TotalScore — though the compiler itself doesn't enforce this; it's a team/community convention worth following anyway.

const double PI = 3.14159;
const int MAX_PLAYERS = 4;

Adding const before a variable's type tells the compiler "this value is set once, right here, and can never change again." If your code later tries to assign a new value to PI, the compiler will refuse to compile it — catching that mistake for you, before your program ever runs.

• It documents intent. Seeing const tells anyone reading the code "this is never supposed to change" — without needing a comment to say so.
• It prevents real bugs. If you accidentally write code that changes a value that should never change, the compiler catches it immediately instead of you discovering it much later as confusing, hard-to-trace behavior.

The convention is to name constants in ALL_CAPS_WITH_UNDERSCORES — this makes them instantly recognizable at a glance, distinct from regular variables.

A literal is a value written directly into your code, rather than stored in a variable — the 5 in int score = 5; is a literal. You've been using literals since the Pre-Course without a name for them; this lesson just gives you the vocabulary.

When both numbers involved in division are int, C++ performs integer division: it throws away any decimal remainder entirely, rather than rounding. 10 / 3 gives 3, not 3.333. To get a decimal result, at least one of the numbers involved needs to actually be a double.

int a = 10, b = 3;
std::cout << a / b;              // prints 3
std::cout << (double)a / b;    // prints 3.33333

% gives you the remainder after division — 10 % 3 is 1, because 3 goes into 10 three times with 1 left over. This shows up constantly in real code: checking if a number is even (n % 2 == 0), wrapping an index around an array's bounds, or converting a total number of seconds into hours/minutes/seconds.

These directly implement the "if it's raining AND I don't have a car" example from the Pre-Course — you're now seeing the real C++ symbols for exactly that logic.

C++ is smart about && and ||: for &&, if the first condition is already false, C++ doesn't even bother checking the second one — the overall result is already known to be false. This is called short-circuit evaluation, and it's more than just an efficiency trick: it's genuinely useful for writing safe checks, like hasAccount && account.balance > 0 — if hasAccount is false, C++ never even attempts to check account.balance, avoiding a potential error from checking something that might not exist.

You've used std::cout since Hello World. The << symbol "sends" a value to the output — you can chain several in one line:

int score = 95;
std::cout << "Your score is: " << score << std::endl;

int age;
std::cout << "Enter your age: ";
std::cin >> age;
std::cout << "You are " << age << " years old." << std::endl;

std::cin pauses your program and waits for the user to type something and press Enter. Notice the arrow direction flips: >> for input (data flows INTO your variable), << for output (data flows OUT to the screen).

std::cin >> someString only reads a single word — it stops at the first space. To read an entire line of text (like a full name), use std::getline instead:

std::string fullName;
std::cout << "Enter your full name: ";
std::getline(std::cin, fullName);

C++ sometimes converts a value's type automatically, without you asking:

double price = 10;   // int 10 automatically becomes 10.0
int total = 9.9;    // double 9.9 automatically becomes 9 (truncated!)

An explicit cast tells C++ "yes, I know this converts types, do it anyway" — making your intent clear in the code itself:

int a = 7, b = 2;
double result = static_cast<double>(a) / b;  // 3.5, not 3

static_cast<double>(a) is the modern, preferred C++ way to explicitly convert a's type to double before the division happens — solving the exact integer-division surprise from Module 4, deliberately and visibly.

if (score >= 90) {
    grade = 'A';
} else if (score >= 80) {
    grade = 'B';
} else if (score >= 70) {
    grade = 'C';
} else {
    grade = 'F';
}

C++ checks each condition in order and stops at the FIRST one that's true — if score is 95, it matches the first condition and never even looks at the rest. The order of your conditions genuinely matters.

For a simple "pick one of two values" decision, C++ offers a shorter form:

// Long form:
std::string status;
if (age >= 18) { status = "adult"; } else { status = "minor"; }

// Ternary shortcut, same result:
std::string status = (age >= 18) ? "adult" : "minor";

Read condition ? valueIfTrue : valueIfFalse exactly like that. It's purely a shorthand for a simple two-way choice — anything more complex should stay a regular if/else for readability.

Without curly braces, if only applies to the single NEXT line — not everything visually indented under it:

if (score > 100)
    std::cout << "High score!";
    score = 100;  // this ALWAYS runs, regardless of the if!

switch (dayNumber) {
    case 1:
        std::cout << "Monday";
        break;
    case 2:
        std::cout << "Tuesday";
        break;
    default:
        std::cout << "Some other day";
}

switch only works for checking one variable against exact, specific values — not ranges or complex conditions. That's exactly what makes it a good fit here (a day number matching an exact case) and a bad fit for something like grade ranges from the last lesson.

Without break, C++ doesn't stop after a matching case — it keeps running every subsequent case's code too, until it hits a break or reaches the end. This is called fall-through, and while occasionally intentional, it's a very common source of bugs when accidentally forgotten.

switch (dayNumber) {
    case 1:
        std::cout << "Monday";
        // missing break! falls through to case 2 too
    case 2:
        std::cout << "Tuesday";
        break;
}

Build a calculator that asks the user for two numbers and an operator (+, -, *, or /), then prints the result — handling the specific gotchas covered in this phase along the way.

• num1 and num2 are double, not int — so the calculator handles decimal input correctly, and division (Module 4's integer-division trap) produces accurate results automatically.
• Division by zero is checked explicitly BEFORE dividing — a real, necessary safeguard, not just defensive-programming paranoia.
• The valid flag prevents printing a meaningless "Result:" line when an error already occurred — the if/else structure from Module 8, doing real work.