The Core Types and const

Every C++ type has a fixed size in memory. That is the deal that makes the language fast: the compiler knows at build time exactly how many bytes each variable needs, so it can lay out memory and emit raw CPU instructions with no runtime type checks. It also means choosing a type is a real engineering decision — in 1996 the Ariane 5 rocket was destroyed seconds after launch partly because a value was converted into an integer type too small to hold it. This lesson gives you the five types that cover nearly all the code you will write.

The five types you will use constantly

Notes for Python programmers:

• Python's int grows without limit. C++'s int is a fixed 32-bit box. If a value can exceed ~2.1 billion (common in interview math), use long long, a 64-bit int.
• float also exists but is less precise than double. Default to double.
• char and std::string are different types: 'A' is one character, "A" is a string containing one character.
• std::string needs #include <string>.

Worked example: when int is not enough

The sum 1 + 2 + ... + n equals n(n + 1)/2. For n = 100,000 that is 5,000,050,000 — bigger than an int's ~2.1 billion ceiling. If you compute it in int arithmetic, the true value cannot fit in the 32-bit box and the stored result is garbage (signed overflow is undefined behavior — the compiler is allowed to assume it never happens). Declaring the variables long long makes every step of the arithmetic 64-bit:

long long n = 100000;
long long sum = n * (n + 1) / 2;   // 5000050000, fits comfortably

The rule interviewers expect you to know: before summing or multiplying, estimate the biggest possible value. Anything that can pass ~2 × 10⁹ goes in long long.

const: values that never change

Mark a variable const and the compiler forbids every later assignment to it:

const double PI = 3.14159;
PI = 3.2;   // COMPILE ERROR: assignment of read-only variable

Python has the ALL_CAPS naming convention for constants, but nothing stops you from reassigning them. In C++, const is enforced by the compiler, just like the type checking you met in lesson 1-3.

Use const on everything that should not change. It documents intent, prevents accidental writes, and later in the course it becomes essential when passing big objects to functions cheaply and safely.