LearnContact
Lesson 68 min read

Variables

When a C++ program runs, it needs a place to store data such as numbers, characters, and calculation results. In this lesson, you will learn what variables are, how to declare them, and how they work in memory.

Introduction

Imagine you are filling out a student admission form. The form contains fields such as Student Name, Roll Number, Age, and Percentage. Each field stores a specific piece of information. Similarly, when a C++ program runs, it needs places to store data. These named storage locations are called variables. Variables are one of the most fundamental concepts in programming because almost every program stores and manipulates data.

What is a Variable?

A variable is a named object used to store data whose value can change during program execution. In simple words, a variable acts like a labeled container for data. Depending on its type and storage, the program can read the stored value, use it in operations, and replace it with another value.

Why Do We Need Variables?

Without Variables

  • Programs could not conveniently store changing information.
  • Calculation results could not be reused easily.
  • User input could not be retained for later processing.
  • Programs would be unable to work effectively with changing data.

With Variables

  • Store data for later use.
  • Perform calculations using stored values.
  • Save and process user input.
  • Update information during program execution.

Real-World Analogy

Imagine several labeled boxes. Each box has a label that identifies it and a value stored inside it. A variable works similarly: the variable name identifies the storage, while the value represents the data currently stored there.

Memory Boxes
+-------------+    +-------------+    +-------------+
| Name        |    | Age         |    | Percentage  |
| Rahul       |    | 20          |    | 92.5        |
+-------------+    +-------------+    +-------------+

Characteristics of Variables

Key Characteristics

Variables have names and types, hold values, occupy storage according to their type and storage duration, and can usually be updated during program execution.

  • Store values used by the program.
  • Have an identifier or variable name.
  • Have a specific data type.
  • Occupy storage while their lifetime is active.
  • Hold one current value at a time.
  • Can usually be updated during program execution.

Declaration, Initialization & Assignment

Declaration

A declaration introduces the variable name and its data type to the compiler.

Initialization

Initialization gives a variable its initial value when the variable is created.

Assignment

Assignment replaces the current value of an existing variable with another value.

Declaration
int age;
Initialization
int age = 20;
Assignment
age = 25; // Replaces the previous value with 25

Memory Representation

Suppose the program contains int age = 20;. Conceptually, the variable can be visualized as a named storage location containing the value 20. The actual memory address is determined by the program execution environment.

Memory View
Variable: age

Address        Value
1000  ─────►   20

(The memory address shown is only an example.)

How Variables Work

Program Starts
↓
Variable is Declared
↓
Storage Becomes Available
↓
Value is Initialized or Assigned
↓
Variable is Read or Updated
↓
Variable Lifetime Ends

Naming Rules

C++ variable names are identifiers and must follow the language rules for identifiers. They may contain letters, digits, and underscores, but they must not begin with a digit or use a reserved C++ keyword.

  • A variable name can contain letters, digits, and underscores.
  • A variable name cannot begin with a digit.
  • Spaces are not allowed inside a variable name.
  • Characters such as @, #, %, and - are not valid identifier characters.
  • Reserved C++ keywords cannot be used as variable names.
  • Variable names are case-sensitive.

Valid Names

  • age
  • studentName
  • salary
  • totalMarks
  • employee_id

Invalid Names

  • 2age — starts with a digit
  • student name — contains a space
  • float — reserved keyword
  • roll-no — contains a hyphen
  • @marks — contains an invalid character

Keywords vs Variables

Keywords are reserved words that have special meanings in the C++ language. Examples include int, float, return, while, and class. These words cannot be used as variable names because the compiler interprets them as part of the language syntax.

Example 1: Declaring and Using Variables

#include <iostream>

int main()
{
    int age = 20;

    std::cout << age;

    return 0;
}

Line 5: int age = 20;

int specifies the variable type, age is the variable name, and 20 is the initial value. The variable is initialized when it is created.

Line 7: std::cout << age;

This sends the current value stored in age to the standard output stream. The program displays 20 rather than the text "age".

Output

20

Example 2: Updating a Variable

#include <iostream>

int main()
{
    int marks = 80;

    std::cout << marks << std::endl;

    marks = 95;

    std::cout << marks;

    return 0;
}

The variable marks is first initialized with the value 80. Later, the assignment marks = 95; replaces the previous value. The variable remains the same variable, but its current stored value changes from 80 to 95.

Memory Update
Before:
marks (1000) ───► 80

After:
marks (1000) ───► 95

(The address is only a conceptual example.)
Output

80 95

Advantages of Variables

Store Data

Variables allow programs to retain values that can be used later.

Simplify Calculations

Stored values can participate in arithmetic and other operations.

Improve Readability

Meaningful variable names make the purpose of data easier to understand.

Support Changing Data

Variable values can be updated as the program processes new information.

Real-World Applications

Banking

Account balances, interest rates, transaction amounts, and account numbers.

Student Management

Student names, marks, roll numbers, attendance, and percentages.

E-Commerce

Product prices, quantities, discounts, taxes, and order totals.

Hospital Systems

Patient names, ages, room numbers, and other application data.

Games

Player scores, health, levels, positions, and game states.

Common Beginner Mistakes

Using Variables Without Declaring Them

A variable must be declared before it is used so the compiler knows its name and type.

Choosing Poor Variable Names

Avoid unclear names when a meaningful name can better describe the purpose of the stored value.

Confusing Assignment (=) with Equality (==)

= assigns a value, while == compares two values for equality.

Using Reserved Keywords

Names such as int, class, and while are reserved by C++ and cannot be used as variable names.

Reading an Uninitialized Local Variable

Using the value of an uninitialized automatic local variable can produce undefined behavior. Initialize variables before reading their values.

Assignment vs Equality
age = 20;  // Assigns 20 to age
age == 20; // Compares age with 20

Best Practices

  • Use meaningful variable names such as studentAge instead of unclear abbreviations.
  • Initialize variables before reading their values.
  • Declare variables close to where they are first used.
  • Follow a consistent naming convention such as camelCase.
  • Use const when a value should not change after initialization.
  • Keep each variable focused on a clear purpose.

Frequently Asked Questions

What is a variable?

A variable is a named object used to store a value that can usually be changed during program execution.

Why do variables need a data type?

The data type determines what kind of values the variable can represent and affects the operations that can be performed on it.

Can the value of a variable change?

Yes. A non-const variable can be assigned new values during its lifetime.

Can two variables have the same name?

Two variables cannot be declared with the same name in the same scope in a way that causes a redeclaration conflict. The same identifier can exist in different scopes.

Where are variables stored?

Variables occupy storage during program execution. The exact storage area depends on factors such as storage duration, scope, type, and implementation.

Key Takeaways

  • Variables allow programs to store and manipulate data.
  • Every variable has a name and a data type.
  • Variables must be declared before they are used.
  • Initialization provides an initial value when a variable is created.
  • Assignment can replace the current value of a variable.
  • Variable names must follow C++ identifier rules.
  • Meaningful names improve code readability and maintainability.

Summary

Variables are a foundation of C++ programming because they provide a way to store, retrieve, and manipulate data during execution. By understanding declaration, initialization, assignment, naming rules, and how variable values change, you gain the ability to build programs that work with dynamic information. Mastering variables is essential because almost every major programming concept depends on storing and processing data.

Next Lesson →

Constants