C Array & Pointer

In C, the relationship between an Array and a Pointer is the foundation of efficient memory management. Here is a clear breakdown of how they interact at a fundamental level.

1. The Hidden Identity

The most important rule in C is this: The name of an array is a pointer to its first element.

When you define int arr[5];, the identifier arr acts as a constant pointer that holds the memory address of arr[0].

• The "Base Address": This is the starting point of the array in RAM.
• The Identity: To the compiler, the name arr is equivalent to writing &arr[0].

2. Pointer Arithmetic (Scaling Logic)

Pointers are "type-aware." When you increment a pointer, it does not move by a single byte; it moves by the size of the data type it points to.

• If ptr points to an integer (4 bytes), ptr + 1 moves the address forward by exactly 4 bytes.
• This ensures the pointer always lands perfectly at the start of the next element in the array.

3. Syntax Equivalence

In C, the square bracket notation [] is actually a "wrapper" for pointer arithmetic. The two columns below are mathematically identical to the computer:

Prof. Echo’s Insight: When you write arr[3], the computer literally calculates *(arr + 3) behind the scenes.

4. Critical Differences

While they share the same logic, there are two major technical differences to keep in mind:

1. Modifiability: An array name is a constant pointer. You cannot change where it points (e.g., arr++ is an error). A pointer is a variable, so it can move freely (ptr++ is valid).
2. Size: * sizeof(arr) returns the memory used by the entire array.
   • sizeof(ptr) returns only the memory used to store the address (usually 4 or 8 bytes).

5. Why This Matters

When an array is passed to a function, it "decays" into a pointer. C does not copy the entire array to the function (which would be slow and memory-intensive); it only passes the address of the first element. This allows the function to access and modify the original data directly.

Summary

• Array: A fixed block of memory.
• Pointer: A variable that holds the address of memory.
• The Link: The array name provides the starting address that the pointer uses to navigate.

To truly understand how the Array-Pointer relationship works, we need to look at how we can access the same data using two different "languages": the Index way and the Pointer way.

Here is a program that demonstrates both methods.

The C Code Example

1#include <stdio.h>
2
3int main() {
4    // 1. Define an array (The "Apartment Row")
5    int snacks[3] = {10, 20, 30};
6
7    // 2. Define a pointer and point it to the array
8    int *ptr = snacks; 
9
10    printf("--- Method 1: Array Indexing ---\n");
11    printf("snacks[0] = %d\n", snacks[0]);
12    printf("snacks[1] = %d\n", snacks[1]);
13
14    printf("\n--- Method 2: Pointer Arithmetic ---\n");
15    // We move the pointer to 'hop' through the memory
16    printf("Value at ptr     (*ptr):       %d\n", *ptr);
17    printf("Value at ptr + 1 (*(ptr + 1)): %d\n", *(ptr + 1));
18    printf("Value at ptr + 2 (*(ptr + 2)): %d\n", *(ptr + 2));
19
20    return 0;
21}

Prof. Echo’s Breakdown

Why *(ptr + 1) works:

When you write ptr + 1, the computer looks at the "type" of the pointer.

1. Since it is an int pointer, the computer knows an int takes up 4 bytes.
2. It calculates: Start Address + (1 * 4 bytes).
3. The * then tells the computer: "Go to that new address and tell me what is inside."

The "Scale" Factor:

If this were a char array (where each letter is only 1 byte), ptr + 1 would only move the address forward by 1 byte. This is why we must always tell C what kind of data the pointer is looking at!

Key Takeaway for the Lesson

In the code above, snacks[1] and *(ptr + 1) are doing the exact same math in the background. The only difference is that snacks[1] is easier for humans to read, while *(ptr + 1) shows you exactly how the CPU is calculating the location.