• +91-9142290450

  • Hajipur, Bihar, 844101

☰
❮
❯

C Memory Address

← Previous Next →

In C programming, every variable, array, or data structure is stored in memory at a specific location. Each of these locations has a unique address, which can be accessed using the address-of operator (&). Understanding memory addresses is fundamental for working with pointers, dynamic memory, and efficient data manipulation.

The concept of memory addresses allows programs to directly access and modify data in memory, making C a powerful language for low-level programming, embedded systems, and performance-critical applications.

What is a Memory Address?

A memory address is a numerical identifier for a location in the computer’s memory where data is stored. Every variable occupies some memory space, and its address tells the program where that data resides.

For example:

int age = 25;

  • The variable age is stored somewhere in memory.

  • Using the address-of operator (&), you can find its memory address:

printf("Address of age: %p\n", &age);

  • %p is the format specifier for printing pointers or addresses.

  • The output will be a hexadecimal number representing the location of age in memory.

The Address-of Operator (&)

The & operator is used to get the memory address of a variable. This is particularly important for pointers and functions that require passing variables by reference.

Example:

#include <stdio.h>

int main() {
    int num = 10;
    printf("Value of num: %d\n", num);
    printf("Address of num: %p\n", &num);
    return 0;
}

  • num holds the value 10.

  • &num provides the memory location where 10 is stored.

Using Memory Addresses with Different Data Types

Every data type occupies a different amount of memory, and its address reflects its location in memory:

#include <stdio.h>

int main() {
    int x = 5;
    float y = 3.14;
    char z = 'A';

    printf("Address of x: %p\n", &x);
    printf("Address of y: %p\n", &y);
    printf("Address of z: %p\n", &z);

    return 0;
}

  • Integers and floats usually occupy 4 bytes, while characters occupy 1 byte.

  • Memory addresses often increment according to the size of the data type.

Why Memory Addresses are Important

  1. Pointers: Variables that store memory addresses rely on knowing where data is stored.

  2. Passing by Reference: Functions can modify variables in the calling function by using addresses.

  3. Dynamic Memory Allocation: Memory addresses are needed to manage memory manually with malloc() or free().

  4. Efficient Access: Direct access to memory can improve performance for large data structures.

Understanding memory addresses bridges the gap between high-level programming and low-level system memory management.

Accessing Data Using Memory Addresses

Once you have a memory address, you can use a pointer to access or modify the value stored at that location.

#include <stdio.h>

int main() {
    int num = 50;
    int *ptr = &num; // pointer stores address of num

    printf("Value of num: %d\n", *ptr); // access value via pointer
    *ptr = 100; // modify value via pointer
    printf("New value of num: %d\n", num);

    return 0;
}

  • int *ptr declares a pointer to an integer.

  • ptr = &num stores the address of num in the pointer.

  • *ptr dereferences the pointer to access or modify the value at that address.

Memory Address in Arrays

Arrays in C are stored in contiguous memory locations. The array name itself represents the address of the first element:

#include <stdio.h>

int main() {
    int arr[3] = {10, 20, 30};

    printf("Address of arr[0]: %p\n", &arr[0]);
    printf("Address of arr[1]: %p\n", &arr[1]);
    printf("Address of arr[2]: %p\n", &arr[2]);
    printf("Address of arr: %p\n", arr);

    return 0;
}

  • arr is equivalent to &arr[0].

  • Each element is stored next to the previous one, with spacing depending on the data type size.

Practical Example: Swapping Values Using Addresses

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 10, y = 20;

    printf("Before swap: x = %d, y = %d\n", x, y);
    swap(&x, &y); // pass addresses
    printf("After swap: x = %d, y = %d\n", x, y);

    return 0;
}

  • Using addresses allows the function to modify variables in the calling function.

  • Demonstrates the importance of memory addresses in pass-by-reference scenarios.

Common Mistakes with Memory Addresses

  1. Forgetting to use & when assigning addresses to pointers.

  2. Using an uninitialized pointer, which can cause undefined behavior.

  3. Dereferencing a pointer that does not point to valid memory.

  4. Confusing the value of a variable with its address.

  5. Miscalculating array element addresses when working with pointers.

Summary of the Tutorial

Every variable in C occupies a memory location with a unique address. The address-of operator (&) allows you to access this memory address. Understanding memory addresses is essential for pointers, arrays, dynamic memory, and efficient data manipulation. By learning to work with memory addresses, you gain a deeper understanding of how C interacts with the computer’s memory and can write programs that are both powerful and efficient.

Practice Questions

  1. Write a program to print the memory address of an integer, a float, and a character variable.

  2. Create a program to swap two numbers using pointers and memory addresses.

  3. Write a program to print the memory addresses of all elements in an integer array.

  4. Develop a program that reads a number from the user and prints both its value and memory address.

  5. Write a program to modify a variable’s value using its memory address and a pointer.

  6. Create a program to print the size (in bytes) and address of different data types like int, float, char, and double.

  7. Write a program to pass an array to a function and print the addresses of its elements inside the function.

  8. Develop a program to swap two floating-point numbers using pointers.

  9. Write a program to increment the value of a variable using a pointer.

  10. Create a program to store the address of a character array (string) in a pointer and print each character using pointer arithmetic.

← Previous Next →

Try a Short Quiz.

coding learning websites codepractice

No quizzes available.

C Programming

online coding class codepractice

Introduction to C

Basics of C

Control Flow

Arrays & Strings

User Input & Output

Pointers

Functions

File Handling

Structures, Unions & Enums

Memory Management

Error Handling & Debugging

Macros and Preprocessors

codepractice logo
Login
Go Back Top