Variables & Constants in C

A variable is a named location associated with storage that can hold a value while a C program is running.

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

Instead of repeatedly writing raw values, we give meaningful names to the information.

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

Beginners often use the words declaration and definition as if they always mean exactly the same thing. In C, the distinction matters.

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 variable is created and given its initial value in the same declaration.

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 identifiers follow specific lexical rules.

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 variable declaration specifies a type. The type determines what kind of object is being declared and how its value is interpreted.

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 */

The preprocessor can define a macro that represents a replacement sequence.

#define PI 3.14159

Later:

double area = PI * radius * radius;

Before compilation, the preprocessor processes the macro according to the rules of preprocessing.

A variable declared inside a function or block generally has block scope and is accessible only within the relevant 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;
}

Global variables can be accessed according to their linkage and scope rules. These topics become more important when studying storage classes and multi-file programs.

A local automatic variable that is defined without an initializer does not automatically receive a useful value.

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;
}

Let's read it like a programmer.

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.