Variables Are Memory Addresses

Variables Are Memory Addresses

Why should you care?

You write:

int age = 20;

It looks like age is simply a box containing the number 20.

But what actually happens in memory?

Where is 20 stored?

How does the computer find it?

And what exactly happens when you write:

age = 21;

Understanding the relationship between variables, memory locations, and addresses is one of the most important steps toward understanding pointers, references, stack memory, heap memory, and low-level programming.

There is one important correction to the title:

A variable is not literally a memory address. A variable is a programming-language abstraction associated with a value and, when applicable, a storage location. That location can have a memory address, but the compiler may also keep the value in a CPU register or optimize the variable away entirely.

The Problem

Consider this C program:

#include <stdio.h>

int main() {
    int age = 20;

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

    return 0;
}

When you write:

int age = 20;

you are telling the compiler that you want a variable called age containing an integer value.

Conceptually, memory might look like:

Memory
┌───────────────┐
│ Address       │
├───────────────┤
│ 0x7FFE1000    │ → 20
└───────────────┘

The address is where the data can be located.

The variable name age is how your source code refers to that value.

So we have:

Variable
   ↓
Storage location
   ↓
Value

But the exact implementation is decided by the compiler and runtime.

The Concept

A memory address identifies a location in an address space.

Imagine memory as a huge collection of numbered locations:

Address       Value

0x1000   →     42
0x1004   →     17
0x1008   →     99
0x100C   →      5

The numbers on the left are addresses.

The numbers on the right are stored values.

When a program needs data, the processor ultimately needs to access the relevant storage location.

For example:

age = 20

might conceptually correspond to:

Address
0x1000
   ↓
Value
20

The address tells the computer where.

The value tells it what.

Simple Explanation

Think of your house.

Your address tells someone where your house is.

Your name identifies who lives there.

Your belongings are the actual things stored inside.

Similarly:

Variable name → age
Memory address → 0x1000
Stored value → 20

These are three different concepts.

age
 ↓
"the integer variable I'm referring to"

0x1000
 ↓
"where the storage is located"

20
 ↓
"the value currently stored there"

This distinction becomes extremely important when learning pointers.

Real-world Analogy

Imagine a library.

Every shelf has a location:

Shelf A12
Shelf B27
Shelf C42

A book has a title:

"Operating Systems"

And the book contains information.

So:

Book name      → Operating Systems
Location       → Shelf B27
Content        → Book's pages

Similarly:

Variable name  → age
Memory address → 0x1000
Value          → 20

The variable name is a convenient way for the programmer to refer to stored data.

Code Example

C allows us to see the address of a variable using the & operator.

#include <stdio.h>

int main() {

    int age = 20;

    printf("Value: %d\n", age);
    printf("Address: %p\n", (void*)&age);

    return 0;
}

You might get output similar to:

Value: 20
Address: 0x7ffd23a4

The exact address will vary between executions.

Now look at the difference:

age

means:

Give me the value of age.

While:

&age

means:

Give me the address of age.

So:

age   → value
&age  → address

This is the foundation of pointers.

Pointers

A pointer is a variable that stores an address.

For example:

#include <stdio.h>

int main() {

    int age = 20;

    int *ptr = &age;

    printf("Value: %d\n", age);
    printf("Address: %p\n", (void*)&age);
    printf("Pointer contains: %p\n", (void*)ptr);

    return 0;
}

Conceptually:

age
┌──────────────┐
│      20      │
└──────────────┘
       ↑
       │
       │ address
       │
ptr
┌──────────────┐
│   0x7FFD...  │
└──────────────┘

The pointer doesn't contain 20.

It contains the address of the memory location where 20 is stored.

Dereferencing

Now we can use the pointer to access the value.

int age = 20;

int *ptr = &age;

printf("%d\n", *ptr);

Output:

20

The * operator here means:

Go to the address stored in ptr
and retrieve the value there.

So:

ptr
 ↓
Address
 ↓
Memory
 ↓
20

This operation is called dereferencing.

Changing a Value Through a Pointer

You can also modify the value through its address.

int age = 20;

int *ptr = &age;

*ptr = 21;

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

Output:

21

What happened?

age
 ↓
Memory location
 ↓
20

*ptr = 21

age
 ↓
Memory location
 ↓
21

The pointer allowed us to access the same storage location indirectly.

Common Mistakes

Mistake 1: Thinking a variable is an address

This is the biggest misconception.

A variable is a language-level abstraction.

It may correspond to a memory location, but it does not necessarily have a permanent physical address.

For example, a compiler may keep:

int x = 10;

inside a CPU register.

In that case, there may be no RAM location associated with x during some part of execution.

Mistake 2: Confusing & and *

In C:

&x

means:

Address of x

while:

*x

when x is a pointer, means:

Value at the address stored in x

Remember:

& → address of
* → dereference

Mistake 3: Thinking addresses never change

A variable's storage location can change during execution depending on the language, runtime, compiler, stack behavior, and memory management.

Modern operating systems also use virtual memory, meaning the address visible to a process is generally a virtual address, not a direct physical RAM address.

Mistake 4: Assuming every variable is stored in RAM

Not necessarily.

A compiler can optimize a variable into:

• CPU registers
• Memory
• Another optimized representation
• No storage at all

For example:

int x = 10;
int y = x + 5;

The compiler may determine that storing x in memory is unnecessary.

Advanced Notes

Virtual Addresses

The address you see in a program is generally a virtual address.

For example:

0x7FFE1234

does not necessarily mean that physical RAM location 0x7FFE1234 contains the data.

Instead:

Virtual Address
       ↓
Memory Management Unit
       ↓
Physical Memory

The operating system and hardware manage this translation.

This is one of the reasons processes can have isolated address spaces.

Stack Variables

Consider:

void function() {

    int x = 10;

}

x has automatic storage duration and is commonly associated with the function's stack frame.

Conceptually:

Stack
┌──────────────┐
│ Local data   │
├──────────────┤
│ x = 10       │
├──────────────┤
│ Return info  │
└──────────────┘

The exact implementation can differ because compilers may optimize local variables into registers or eliminate them.

Heap Variables

Dynamically allocated memory is commonly associated with the heap.

For example:

int *ptr = malloc(sizeof(int));

*ptr = 50;

Conceptually:

ptr
 ↓
Address
 ↓
Heap
┌──────────────┐
│      50      │
└──────────────┘

Here, ptr stores an address pointing to dynamically allocated storage.

What About Java?

Java makes this concept slightly different.

Consider:

int age = 20;

You cannot directly obtain the raw memory address of age using normal Java language features.

Java intentionally hides direct memory manipulation from ordinary application code.

For objects:

Person person = new Person();

person is better understood as a reference to an object, not as a C-style pointer that programmers can freely perform arithmetic on.

This abstraction provides safety and allows the JVM and garbage collector to manage memory.

So the relationship is:

C

Variable → Memory location → Address


Java

Variable → Value or Reference → Object

The JVM decides how and where objects are actually represented.

The Bigger Picture

This concept connects several important areas of computer science.

Variables
    ↓
Memory
    ↓
Addresses
    ↓
Pointers / References
    ↓
Stack & Heap
    ↓
Virtual Memory
    ↓
Operating System
    ↓
CPU

Once you understand this chain, concepts such as:

• Pointers
• References
• Arrays
• Function calls
• Stack frames
• Dynamic memory
• Garbage collection
• Virtual memory

become much easier to understand.

Summary

A variable is not literally a memory address.

Instead, think of three separate concepts:

Variable
   ↓
Storage
   ↓
Value

When storage has an address, we can think of:

Variable → Address → Value

For example:

age
 ↓
0x7FFE1000
 ↓
20

In C:

age

accesses the value.

&age

gets its address.

And:

*ptr

dereferences an address stored in a pointer.

The deeper lesson is that programming languages give us abstractions over the physical machine. Sometimes a variable corresponds to memory, sometimes it lives in a register, and sometimes the compiler eliminates it completely.

Understanding that distinction is the first step toward thinking like a systems programmer.