C Language Series #39: Pointers and Arrays – An Inseparable Bond

Welcome back to our C Language Series! In the intricate world of C programming, few concepts are as fundamental and deeply intertwined as pointers and arrays. Understanding their relationship isn't just a matter of theoretical knowledge; it's essential for writing efficient, flexible, and powerful C code, especially when dealing with memory management and data structures. This post will delve into what arrays and pointers are individually, and then unravel the profound connection that makes them almost two sides of the same coin in C.

What is an Array?

An array is a collection of elements of the same data type, stored in contiguous memory locations. It's a way to store multiple values under a single variable name, accessed via an index.

When you declare an array, the compiler allocates a block of memory large enough to hold all its elements back-to-back. The name of the array then serves as a reference to this block.

#include <stdio.h>

int main() {
    // Declare and initialize an integer array
    int numbers[5] = {10, 20, 30, 40, 50};

    // Accessing elements using array indexing
    printf("First element: %d\n", numbers[0]);   // Output: 10
    printf("Third element: %d\n", numbers[2]);   // Output: 30

    // Modifying an element
    numbers[1] = 25;
    printf("Modified second element: %d\n", numbers[1]); // Output: 25

    return 0;
}
    

What is a Pointer?

A pointer is a variable that stores the memory address of another variable. Instead of holding a data value directly, it holds the location where that value is stored in memory. Pointers are crucial for dynamic memory allocation, efficient array manipulation, and building complex data structures.

• Declaration: Declared using the asterisk (*) symbol, e.g., int *ptr;.
• Initialization: Assigned the address of a variable using the address-of operator (&), e.g., ptr = #.
• Dereferencing: Accessing the value at the memory address stored in the pointer, also using the asterisk (*) operator, e.g., *ptr = 100;.

#include <stdio.h>

int main() {
    int value = 100;
    int *ptr_value; // Declare a pointer to an integer

    // Store the address of 'value' in 'ptr_value'
    ptr_value = &value;

    printf("Value: %d\n", value);                   // Output: 100
    printf("Address of value: %p\n", (void*)&value); // Output: memory address
    printf("Pointer stores address: %p\n", (void*)ptr_value); // Output: same memory address

    // Dereference the pointer to access the value
    printf("Value using pointer: %d\n", *ptr_value); // Output: 100

    // Modify value using pointer
    *ptr_value = 200;
    printf("New value: %d\n", value);               // Output: 200

    return 0;
}
    

The Profound Relationship: Arrays and Pointers

In C, arrays and pointers are intrinsically linked. This relationship is one of the most powerful and often confusing aspects for newcomers, but once understood, it unlocks a deeper understanding of C's memory model.

Arrays as Pointers (and Vice-versa)

The most critical aspect of their relationship is that, in most contexts, the name of an array acts as a constant pointer to its first element. This means that if you have an array int arr[5];, the expression arr (without any brackets or indices) evaluates to the memory address of the first element, i.e., &arr[0].

Because the array name effectively behaves like a pointer, you can use pointer arithmetic to traverse and access array elements.

#include <stdio.h>

int main() {
    int scores[3] = {90, 85, 92};

    printf("Address of scores[0]: %p\n", (void*)&scores[0]); // Address of first element
    printf("Value of array name (scores): %p\n", (void*)scores); // Same address as first element

    // Accessing elements using pointer arithmetic
    printf("scores[0] using pointer arithmetic: %d\n", *(scores + 0)); // Same as scores[0]
    printf("scores[1] using pointer arithmetic: %d\n", *(scores + 1)); // Same as scores[1]
    printf("scores[2] using pointer arithmetic: %d\n", *(scores + 2)); // Same as scores[2]

    return 0;
}
    

As you can see, scores[i] is completely equivalent to *(scores + i). The square bracket [] notation is merely syntactic sugar for pointer arithmetic and dereferencing.

Pointer Arithmetic with Arrays

Since an array name can be treated as a pointer, you can perform pointer arithmetic on it. When you add an integer n to a pointer p (e.g., p + n), the address is incremented by n * sizeof(data_type_pointed_to) bytes. This allows you to move across the contiguous memory block of an array.

#include <stdio.h>

int main() {
    int data[] = {100, 200, 300, 400};
    int *p_data = data; // p_data now points to data[0]

    printf("Element at p_data (data[0]): %d\n", *p_data); // Output: 100

    p_data++; // Increment pointer to point to the next element (data[1])
    printf("Element at p_data after increment (data[1]): %d\n", *p_data); // Output: 200

    p_data += 2; // Increment pointer by 2 positions (now points to data[3])
    printf("Element at p_data after increment by 2 (data[3]): %d\n", *p_data); // Output: 400

    return 0;
}
    

Passing Arrays to Functions

When you pass an array as an argument to a function in C, it's not the entire array that gets copied. Instead, a pointer to its first element is passed. This means that inside the function, the array parameter is treated as a pointer.

#include <stdio.h>

// Function takes an array (which decays to a pointer)
void printArray(int arr[], int size) {
    // Inside the function, 'arr' is treated as an 'int *'
    printf("Inside function: Address of arr parameter: %p\n", (void*)arr);
    printf("Inside function: Size of arr parameter (is size of pointer): %zu bytes\n", sizeof(arr));

    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int myNumbers[] = {1, 2, 3, 4, 5};
    int arraySize = sizeof(myNumbers) / sizeof(myNumbers[0]);

    printf("Outside function: Address of myNumbers: %p\n", (void*)myNumbers);
    printf("Outside function: Size of myNumbers array: %zu bytes\n", sizeof(myNumbers));

    printArray(myNumbers, arraySize); // Pass the array (decays to a pointer)

    return 0;
}
    

Notice in the output that sizeof(arr) inside the function reports the size of a pointer (typically 4 or 8 bytes), not the size of the original array. This confirms that the function receives a pointer.

Key Differences and Nuances

While arrays and pointers are closely related, they are not identical. Understanding their distinctions is crucial to avoid common pitfalls.

1. Modifiability: An array name is a constant pointer to its first element. You cannot reassign an array name to point to a different memory location. A pointer variable, however, can be reassigned to point to different addresses.

   
   int arr[5];
   int *ptr;
   
   ptr = arr;   // Valid: pointer can point to the array
   // arr = ptr; // INVALID: array name cannot be reassigned
   ptr = &arr[2]; // Valid: pointer can be reassigned
               

2. sizeof Operator: This is a common point of confusion.
   • sizeof(array_name): Returns the total size in bytes of the entire array.
   • sizeof(pointer_variable): Returns the size in bytes of the pointer variable itself (typically 4 or 8 bytes on 32-bit and 64-bit systems respectively), regardless of what it points to.

   
   #include <stdio.h>
   
   int main() {
       int data[5] = {10, 20, 30, 40, 50};
       int *p = data; // p points to the first element of data
   
       printf("Size of array 'data': %zu bytes (5 ints * %zu bytes/int)\n",
              sizeof(data), sizeof(data[0])); // Output: 20 bytes (assuming int is 4 bytes)
   
       printf("Size of pointer 'p': %zu bytes\n", sizeof(p)); // Output: 8 bytes (on a 64-bit system)
       printf("Size of first element 'data[0]': %zu bytes\n", sizeof(data[0])); // Output: 4 bytes
   
       return 0;
   }
               

3. Memory Allocation: Arrays have memory allocated at compile time (for static/global) or on the stack (for local variables). Pointers can point to memory allocated anywhere, including the heap using functions like malloc().

Conclusion

The relationship between pointers and arrays is one of the cornerstones of C programming. Understanding that an array name often decays into a pointer to its first element, and that array indexing is merely syntactic sugar for pointer arithmetic, is fundamental. This knowledge empowers you to write more efficient code, manage memory effectively, and fully leverage the flexibility that C offers. Master this connection, and you'll unlock a deeper level of proficiency in C programming.