C++ Variables: Declaring, Initializing, and Scope Explained

What a Variable Is

A variable is a named piece of memory that holds a value. In C++ every variable has a fixed type - chosen when you declare it - and that type never changes. This is what makes C++ statically typed: the compiler knows the type of every variable before the program runs and refuses to compile code that stores the wrong kind of value.

A declaration has three parts: the type, the name, and (almost always) an initial value.

#include <iostream>
#include <string>
using namespace std;

int main() {
    int age = 30;
    string name = "Ada";
    bool isActive = true;

    cout << name << " is " << age << ", active: " << isActive << "\n";
    return 0;
}

Read int age = 30; as "make an int called age and put 30 in it". The semicolon ends the statement, just like the comments page showed every statement does. Note isActive printed as 1 - bool shows as 1/0 by default, something the data types page builds on.

Initialization vs. Assignment

These two look similar but are different operations, and the difference is one of the most important ideas on this page.

Initialization gives a variable its first value as part of the declaration. Assignment changes the value of a variable that already exists.

#include <iostream>
using namespace std;

int main() {
    int score = 95;   // initialization - first value, given at declaration
    score = 100;      // assignment - changing an existing variable
    score = score + 5;

    cout << score << "\n";
    return 0;
}

You can declare without initializing, then assign later, but be careful:

#include <iostream>
using namespace std;

int main() {
    int score;     // declared, but holds garbage right now
    score = 95;    // now it has a real value
    cout << score << "\n";
    return 0;
}

That works because we assigned score before reading it. The dangerous version is reading it first - covered next.

The Uninitialized-Variable Gotcha

This is the classic C++ trap that does not exist in many other languages. Reading a local variable that was declared but never given a value is undefined behavior: the variable holds whatever bytes happened to be in that memory.

int score;             // not initialized
std::cout << score;    // undefined behavior - prints garbage, or "works", or crashes

The compiler will happily build this. It may print 0, it may print 32766, and it may behave differently every run or on every machine - which makes these bugs miserable to track down. Two defenses:

• Always initialize at declaration. int score = 0; costs nothing and removes the entire problem.
• Turn on warnings. Compiling with -Wall -Wextra makes the compiler flag many uninitialized reads before they bite you.

Prefer the first option for every local: give it a sensible starting value the moment you create it.

Initialization Styles: =, (), and {}

C++ gives you a few ways to write an initial value. They mostly do the same thing, but brace initialization has one extra safety feature worth knowing.

#include <iostream>
using namespace std;

int main() {
    int a = 5;     // copy initialization
    int b(5);      // direct initialization
    int c{5};      // brace (uniform) initialization - C++11 and later

    cout << a << " " << b << " " << c << "\n";
    return 0;
}

The reason to reach for {} is that it rejects narrowing conversions - assignments that would silently lose data. With =, a fractional value quietly truncates; with {}, the compiler stops you:

int x = 3.9;    // compiles - x silently becomes 3 (the .9 is thrown away)
int y{3.9};     // compile error - narrowing from double to int is not allowed

Catching that at compile time is exactly what you want. A common modern habit is to default to {} for that extra check, falling back to = only when copy initialization reads more naturally.

Naming Rules and Conventions

C++ enforces a few hard rules, then everyone layers conventions on top. The rules: a name may contain letters, digits, and _; it cannot start with a digit; it cannot be a reserved keyword (like int or return); and it is case-sensitive (age and Age are two different variables). Avoid names that start with an underscore followed by a capital, or that contain two underscores in a row - those are reserved for the implementation.

The conventions most C++ code follows:

• Variables use snake_case or camelCase - pick one and stay consistent: item_count or itemCount.
• Names should describe the value: count, not c; user_email, not x.

#include <iostream>
using namespace std;

int main() {
    int item_count = 3;
    double price_per_item = 4.50;
    double total_price = item_count * price_per_item;

    cout << "Total: " << total_price << "\n";
    return 0;
}

Clear names are not decoration - they are how your future self reads the code. total_price = item_count * price_per_item is self-explanatory in a way t = c * p never will be.

Variable Scope

A variable exists only inside the block - the { ... } - where it is declared, and it is destroyed at the closing brace. This is its scope. A variable declared inside a loop or if block is invisible outside it:

#include <iostream>
using namespace std;

int main() {
    int total = 0;

    for (int i = 1; i <= 3; i++) {
        int square = i * i;   // 'square' lives only inside this loop body
        total += square;
    }

    cout << "Total: " << total << "\n";
    // cout << square;   // error - 'square' is out of scope here
    return 0;
}

Both i and square belong to the loop and vanish when it ends; total is declared in the outer block, so it survives. An inner block can also shadow a name from an outer block - a new variable with the same name temporarily hides the outer one until the inner block closes, which is a frequent source of confusion, so avoid reusing names across nested scopes.

The practical takeaway: declare each variable in the smallest block that needs it, and initialize it there. Narrow scope means fewer names competing for your attention and fewer chances to read a value far from where it was set.

Next: Data Types

Every variable on this page started with a type - int, double, string, bool. The next page breaks down C++'s data types in detail: the fundamental types and their sizes, signed vs. unsigned integers, float vs. double, char, and how to pick the right type for the job.