🔤 3. Variables & Constants in C

A variable names storage that holds a value while the program runs.

Think of a variable as a labeled container:

        VARIABLE
           │
           ▼
    ┌─────────────┐
    │    age      │  ← name
    ├─────────────┤
    │     20      │  ← current value
    └─────────────┘
           │
           ▼
       memory

In this example, age is the variable name and 20 is its current value.

Programs work with changing information. For example:

• a student's marks
• a person's age
• the price of a product
• the number of employees
• a calculated result
• user input

A meaningful name shows what a value represents. For example, marks is easier to understand in a calculation than an unexplained number.

int marks = 85;

Later, the program can use marks:

printf("%d", marks);

A variable declaration tells the compiler about the variable's type and name.

int age;

Here:

int age;
│   │
│   └── variable name
│
└────── data type

A declaration tells the compiler about a name. A definition also supplies the variable or function itself. One line can do both, as the local-variable example below shows.

For a simple local variable:

int age;

This is a declaration and also a definition of the local variable.

Giving a variable its initial value when it is defined is called initialization.

int age = 20;

int age = 20;

   age
    │
    ▼
 ┌──────┐
 │  20  │
 └──────┘

The same declaration introduces the variable and gives it its first value.

int age;       // declaration/definition

age = 20;      // assignment

int marks = 85; // declaration/definition + initialization

int score = 50;

score = 75;

score = 90;

The variable score has one current value at a time. Assignment can replace that current value.

Start
score → 50

   ↓

score = 75

   ↓

score → 75

   ↓

score = 90

   ↓

score → 90

The name of a variable is an identifier. Identifiers are also used for functions, arrays, structures, and other programmer-defined entities.

Examples:

age
studentMarks
total
average
employee_count

C has rules for spelling identifiers, the names used for variables and functions.

1. They can contain letters, digits and underscore.
2. They cannot contain spaces.
3. They cannot begin with a digit.
4. C identifiers are case-sensitive.
5. A keyword cannot be used as an ordinary variable name.

Uppercase and lowercase letters are different in C.

int age = 20;
int Age = 30;

printf("%d\n", age);
printf("%d\n", Age);

Here, age and Age are two different identifiers.

age  → 20

Age  → 30

They are different identifiers.

Multiple variables of the same type can be declared together.

int a, b, c;

They may also be initialized:

int a = 10, b = 20, c = 30;

A declaration gives a variable a type. That type describes the values it can hold and affects the operations you can perform with it.

int age = 20;
float price = 99.50f;
char grade = 'A';

Data types are covered in detail in the next lesson.

A constant is a value that does not change during the relevant use of a program.

C provides several ways to represent constant values.

10
3.14
'A'
"Hello"

These are examples of literal values used directly in source code.

Variable

   name
    │
    ▼
 ┌──────┐
 │  20  │
 └──────┘
    │
    └── can be changed


Constant

    100
     │
     └── fixed value

A literal is a value written directly in the source code.

The const qualifier can be used when an object should not be modified through that particular declaration.

const int MAX_MARKS = 100;

After initialization, attempting to modify the object through this const-qualified declaration is not allowed.

const int MAX_MARKS = 100;

/* MAX_MARKS = 120;  ← constraint violation */

A macro gives a name to replacement text that the preprocessor uses before compilation.

#define PI 3.14159

Later:

double area = PI * radius * radius;

Before compilation, the preprocessor replaces uses of this object-like macro with its replacement text.

A local variable is declared inside a function or block. Its name can be used only within the part of the source where that declaration is in scope.

int main(void)
{
    int age = 20;

    printf("%d", age);

    return 0;
}

Here, age is declared inside main.

main()
 │
 ├── age
 │
 ├── printf()
 │
 └── return

int main(void)
{
    int x = 10;

    {
        int y = 20;

        printf("%d %d", x, y);
    }

    return 0;
}

The inner block can use x because x belongs to an enclosing scope. The variable y belongs to the inner block.

main block
│
├── x
│
└── inner block
    │
    └── y

A variable defined outside all functions has file scope by default. Such a variable is commonly called a global variable.

int count = 0;

int main(void)
{
    count = 10;

    printf("%d", count);

    return 0;
}

A global variable’s declaration and linkage determine where its name can be used, including whether it can be shared across source files. The Storage Classes lesson explains these rules.

An ordinary local variable without an initializer does not start with a reliable value. Give it a value before reading it.

int main(void)
{
    int x;

    printf("%d", x);

    return 0;
}

Prefer:

int x = 0;

int balance = 1000;

balance = 750;

balance = balance + 250;

After the first assignment, balance becomes 750. The next statement calculates 750 + 250 and stores the result.

balance = 1000
      │
      ▼
balance = 750
      │
      ▼
balance = 750 + 250
      │
      ▼
balance = 1000

#include <stdio.h>

int main(void)
{
    int marks1 = 80;
    int marks2 = 90;
    int total;

    total = marks1 + marks2;

    printf("Total = %d\n", total);

    return 0;
}

Trace each assignment in order and keep track of the current values.

Program
│
├── #include <stdio.h>
│   └── provides declaration for printf()
│
├── main()
│
├── marks1
│   └── 80
│
├── marks2
│   └── 90
│
├── total
│   └── marks1 + marks2
│
├── printf()
│   └── displays total
│
└── return 0

The important point is that the variables allow the program to give names to the data it is processing.

Two ideas are important when studying variables:

These concepts are closely related to storage duration and storage classes, which will be studied later.

1. Using a variable before giving it a meaningful value.
2. Using a keyword as a variable name.
3. Starting an identifier with a digit.
4. Forgetting that C is case-sensitive.
5. Confusing = with mathematical equality.
6. Trying to modify a const-qualified object.
7. Assuming #define creates a normal C variable.