When you start working with arrays in C, one of the first practical skills you need is passing them to functions. It helps you organize your code, reuse logic, and keep things clean. Instead of writing everything in main(), you can move array operations into separate functions.
 Here’s the thing: arrays behave a little differently when passed to functions compared to normal variables, and understanding that makes a big difference.
 

Table of Contents

---

What Does Passing an Array Mean?

Passing an array to a function means sending the array’s data so the function can process it. In C, when you pass an array, you are actually passing the address of its first element, not the entire array copy.

1. Changes made inside the function affect the original array.
2. No extra memory is used to copy the array.

Syntax for Passing Arrays to Functions:

return_type function_name(data_type array_name[], int size);
Or 
return_type function_name(data_type *array_name, int size);

Both forms are equivalent.

Passing Array to Print Elements

Below is the C program to pass array to functions and print the elements:

// C program to pass an array and 
// print the elements
#include stdio.h

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

int main() 
{
    int numbers[] = {10, 20, 30, 40, 50};
    int size = 5;

    printArray(numbers, size);

    return 0;
}

Output:

10 20 30 40 50 

Explanation:
The array numbers is passed to printArray(). The function receives the address of the first element and uses it to access all elements. Since arrays are passed by reference, no duplication happens.

Modifying Array Elements in a Function

Below is the C program to modify the array elements in a function:

// C program to modify array elements
// in a function
#include stdio.h

void updateArray(int arr[], int size) 
{
    int i;
    for(i = 0; i  size; i++) 
    {
        arr[i] = arr[i] * 2;
    }
}

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

    updateArray(numbers, size);

    for(i = 0; i  size; i++) 
    {
        printf("%d ", numbers[i]);
    }

    return 0;
}

Output:

2 4 6 8 10 

Explanation:
The function modifies each element of the array. Since the array’s address is passed, the original array in main() gets updated directly.

Passing Array Using Pointer

Below is the C program to pass array using pointers:

// C program to pass array using pointers
#include stdio.h

void sumArray(int *arr, int size) 
{
    int i, sum = 0;

    for(i = 0; i  size; i++) 
    {
        sum += arr[i];
    }

    printf("Sum = %d", sum);
}

int main() 
{
    int numbers[] = {5, 10, 15, 20};
    int size = 4;

    sumArray(numbers, size);

    return 0;
}

Output:

Sum = 50

Explanation:
Here, the array is passed using a pointer. This is just another way of handling arrays, since arrays decay into pointers when passed to functions.

Key Concepts of Passing Arrays to Functions

1. Arrays Pass Memory Address Instead of Complete Data: When an array is passed to a function in C, the whole array is not copied. The function receives the address of the first element, which helps save memory and improve performance.
2. Original Array Can Be Modified: Changes made inside the function affect the original array because both the function and the main program access the same memory location.
3. Array Size Must Be Passed Separately: C does not automatically determine the number of elements in an array when it is passed to a function. The size should always be sent as an additional parameter.
4. Array Notation and Pointer Notation Work the Same: You can pass arrays using arr[] or *arr. Both methods work similarly because arrays behave like pointers inside functions.
5. Passing Arrays Improves Code Reusability: Using functions with arrays helps avoid repeated code. The same function can process different arrays whenever required.
6. Memory Usage Becomes More Efficient: Since C passes only the address of the array and not a duplicate copy, additional memory consumption is reduced.
7. Functions Can Perform Multiple Operations on Arrays: A function can be created for different array tasks such as printing values, finding sums, sorting elements, searching data, and updating values.
8. Array Elements Remain in Continuous Memory Locations: Array elements are stored one after another in memory. This makes traversal and processing faster when functions access the array.
9. Incorrect Size May Produce Errors: If the wrong array size is passed, the function may access invalid memory locations and produce unexpected results.
10. Passing Arrays Makes Programs Modular: Breaking array operations into separate functions makes programs easier to read, manage, test, and maintain.

Common Mistakes While Passing Arrays to Functions

1. Forgetting to Pass the Array Size: Many beginners pass only the array and forget the size, which causes problems while accessing elements.
2. Assuming a New Array Copy Is Created: Some programmers think the function receives a separate array copy, but it actually works with the original data.
3. Accessing Elements Beyond the Array Limit: Using indexes outside the valid range can lead to incorrect output or runtime issues.
4. Using Wrong Data Types: The array type in the function should match the original array type to avoid errors.
5. Ignoring Changes Made Inside Functions: Since the original array gets modified, ignoring these changes may produce unexpected results later in the program.

Conclusion

Passing arrays to functions in C is a core concept that helps you write modular and reusable programs. Once you understand that arrays are passed by reference, it becomes easier to manipulate data efficiently.
 This approach not only saves memory but also simplifies complex operations. With practice, you will naturally start structuring your programs using functions and arrays together.

Frequently Asked Questions

1. Are arrays passed by value or reference in C?

Arrays are passed by reference, meaning their memory address is shared with the function.

2. Why do we pass array size separately?

C does not automatically track array size, so you must pass it to avoid accessing invalid memory.

3. Can a function return an array in C?

A function cannot directly return an array, but it can return a pointer to an array.

4. What happens if we modify an array inside a function?

The original array gets modified because the function works on the same memory location.

5. Is pointer notation different from array notation?

No, both are equivalent when passing arrays to functions.