Pointers and Arrays

In C, pointers and arrays are closely related concepts. Arrays provide a way to store multiple values of the same type in a contiguous block of memory, while pointers allow you to access and manipulate memory addresses directly. Understanding how pointers and arrays work together is essential to efficiently managing memory and handling dynamic data in C.

1. Pointers and Arrays Relationship

An array name acts like a pointer to the first element of the array. Therefore, when you use the array name, it represents the address of the first element.

For example:

int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;  // ptr points to the first element of arr

Here:

• arr is the name of the array and represents the address of the first element arr[0].
• ptr is a pointer that also holds the address of the first element of arr.

Example of Accessing Array Elements with Pointers

You can use a pointer to access elements of an array by moving the pointer across the array using pointer arithmetic.

#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *ptr = arr;

    // Accessing array elements using the pointer
    for (int i = 0; i < 5; i++) {
        printf("Element %d: %d\n", i, *(ptr + i));
    }

    return 0;
}

Explanation:

• ptr points to the start of arr, so *ptr is equivalent to arr[0].
• *(ptr + i) accesses the i-th element of arr using pointer arithmetic.

2. Passing Arrays to Functions Using Pointers

When you pass an array to a function, you’re actually passing a pointer to the first element of the array. This allows the function to modify the original array.

Example of Passing an Array to a Function:

#include <stdio.h>

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

int main() {
    int arr[5] = {1, 2, 3, 4, 5};

    // Passing the array to the function
    printArray(arr, 5);

    return 0;
}

Explanation:

• The printArray function takes a pointer array (which points to arr in main), and prints each element.
• Since arr is passed as a pointer, printArray can access and modify the original elements of arr.

3. Using Pointers to Dynamically Allocate Arrays

Pointers enable you to allocate arrays dynamically using functions like malloc, calloc, and realloc.

Example of Dynamically Allocating an Array:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n = 5;
    int *arr = (int*)malloc(n * sizeof(int));

    // Check if memory allocation was successful
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // Assign values to dynamically allocated array
    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;
    }

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

    // Free allocated memory
    free(arr);

    return 0;
}

Explanation:

• malloc dynamically allocates memory for an array of integers.
• We access elements using arr[i], just like a regular array.
• free(arr) releases the allocated memory to prevent memory leaks.

4. Pointer Notation vs. Array Notation

You can use either array notation (arr[i]) or pointer notation (*(arr + i)) to access elements of an array. Both are equivalent, but pointer notation is useful in contexts where you only have a pointer (not an array).

Example of Both Notations:

#include <stdio.h>

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

    printf("Using array notation:\n");
    for (int i = 0; i < 3; i++) {
        printf("%d ", arr[i]);
    }

    printf("\nUsing pointer notation:\n");
    for (int i = 0; i < 3; i++) {
        printf("%d ", *(arr + i));
    }

    return 0;
}

Explanation:

• The output will be the same for both notations: 10 20 30.
• This demonstrates how arr[i] and *(arr + i) are interchangeable.

Summary

• Array names act as pointers to the first element of the array.
• Pointer arithmetic allows you to access array elements through a pointer.
• Arrays can be passed to functions using pointers.
• Pointers can be used to dynamically allocate arrays for flexible memory management.