1.1 Declaring and Initializing Variables

Variables are the names we give to storage locations in our computer's memory. When you declare a variable in C++, you are telling the compiler to reserve a specific amount of physical RAM, label it with your variable's name, and prepare it to store a certain type of data.

Unlike JavaScript or Python where variables can hold a string, then a float, then an array because they have type identity crises, C++ is a strongly typed language. Once a variable is declared as an integer, it is an integer forever. It cannot marry a string later.

When you declare variables inside a function (like main), they are allocated on the stack. The compiler calculates the exact size of all local variables at compile time and shifts the stack pointer register (rsp) to allocate a block of memory (called a stack frame) when the function is called.

Here is what stack memory physically looks like when declaring an integer x set to 5:

Address          Memory Contents       Variable name
0x7ffee3c8a1b0   [ 05 00 00 00 ]       x (4 bytes)
0x7ffee3c8a1b4   [ xx xx xx xx ]       Padding / Unallocated
0x7ffee3c8a1b8   [ rbp address ]       Saved Stack Frame Pointer

When you ask the computer for memory to store a variable, the operating system gives you a slice of RAM. However, C++ does not automatically zero out or clean that RAM. It just hands it to you.

If you declare a variable without giving it a value, it will contain whatever random binary leftovers were in that RAM from whatever program was running there five minutes ago. These are called garbage values, and reading from them leads to undefined behavior (UB). Your program might print a random number, crash, or summon ghosts; the compiler makes no guarantees.

#include <iostream>

int main() {
    int x; // Uninitialized! Contains garbage values.
    std::cout << x << std::endl; // DANGEROUS: Prints whatever garbage was in that memory location.
    return 0;
}

To avoid garbage values, I recommend that you always initialize your variables when you declare them. C++ supports three main initialization styles, but modern C++ strongly advocates for one in particular:

1. Copy Initialization (C style)

int width = 5;

This is inherited from C. It copies the value on the right into the variable on the left. It works fine for simple types, but is less efficient for complex objects.

2. Direct Initialization

int width(5);

Direct initialization looks like a function call. It is rarely used in modern code because it has been superseded by uniform initialization.

3. Brace (Uniform) Initialization

int width{5};

Introduced in C++11, brace initialization (also known as list initialization) is the recommended modern standard for initializing variables. It has two massive advantages:

* Value Initialization: If you leave the braces empty (e.g. int width{};), C++ guarantees the variable is initialized to its default value (which is 0 for numbers). No more garbage memory ghosts!

* Prevents Narrowing Conversions: If you try to assign a floating point number (like 4.5) to an integer using copy or direct initialization, the compiler will silently slice off the decimal and make it 4. Using brace initialization, the compiler will throw a compilation error, saving you from subtle bugs.

Here is what the compiler actually throws if you try to assign a double to an int using brace initialization:

error: narrowing conversion of '4.5e+0' from 'double' to 'int' inside { } [-Wnarrowing]
   int z{4.5};
         ^~~

When we write modern C++, we must build the habit of using brace initialization for all our variable declarations. It is safer, uniform, and makes your code predictable.

int apples{10};    // Explicitly set to 10
int oranges{};     // Automatically initialized to 0
double pi{3.1415}; // Explicitly set to 3.1415