Difference between passing array and array pointer into function in C

In C, there are key differences in how arrays and pointers to arrays are handled when passed to functions, which impact function design and memory usage. Below, I will provide a detailed explanation of both approaches along with relevant code examples.

1. Array Passing to Functions

When an array is passed as a parameter to a function, the address of the first element is typically passed. In the function's parameter list, this is commonly represented as an array or a pointer. It is important to note that while the array name denotes the address of the first element, the function cannot directly determine the original array's size (length) unless the length is explicitly provided.

Code Example:

c
#include <stdio.h>

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

int main() {
    int myArray[] = {1, 2, 3, 4, 5};
    int n = sizeof(myArray) / sizeof(myArray[0]);
    printArray(myArray, n);
    return 0;
}

In this example, myArray is passed to printArray, where the address of the first element is passed. The function receives the array address via the parameter int arr[] and knows the array length through the size parameter.

2. Pointer to Array Passing to Functions

A pointer to an array is a pointer that stores the address of an array and can access subsequent elements by incrementing the pointer. When a pointer to an array is passed to a function, the original array can be modified within the function, which is particularly useful for handling dynamic multi-dimensional arrays.

Code Example:

c
#include <stdio.h>

void modifyArray(int (*pArr)[5], int size) {
    for (int i = 0; i < size; i++) {
        (*pArr)[i] += 5; // Add 5 to each element
    }
}

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

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

    return 0;
}

In this example, the address of myArray is passed to modifyArray via &myArray. The function receives the pointer to the array via int (*pArr)[5] and can directly modify the original array's content.

Summary

• Passing Arrays: Typically passes the address of the first element; the function does not know the array's length internally, requiring explicit length information to be passed.
• Passing Pointers to Arrays: Passes a pointer to the array, allowing modification of the array's content within the function, which is particularly useful for dynamic arrays and multi-dimensional arrays.

In practice, the choice depends on specific requirements, such as whether modification of the array content within the function is needed, and whether the array's length is relevant.