C - Passing Arrays to Function

Why This Matters

In C programming, understanding how to pass arrays to functions is crucial for writing efficient and reusable code. Arrays are often used to store and manipulate large amounts of data, so it's essential to know how to process them effectively within functions. This lesson will guide you through the process of passing arrays to C functions, helping you avoid common pitfalls and write cleaner, more efficient code.

Prerequisites

Before diving into passing arrays to functions, it's essential to have a solid understanding of:

1. Basic data types in C, including int, char, and float.
2. Variables and their declaration.
3. Arrays and their creation, access, and manipulation.
4. Functions and function prototypes.
5. Pass-by-value and pass-by-reference concepts.

Core Concept

Array Basics

An array in C is a collection of elements of the same data type stored contiguously in memory. To create an array, we specify its data type followed by square brackets []. For example:

int arr[5]; // creates an array of 5 integers
char names[10][20]; // creates an array of 10 character arrays, each with a maximum length of 20 characters

Passing Arrays to Functions: Pass-by-Value and Pass-by-Reference

When we pass an array as an argument to a function, it gets passed by reference. However, the way C handles this can lead to confusion, especially for beginners. There are two main ways to pass arrays to functions in C: pass-by-value and pass-by-reference.

Pass-by-Value (Default Behavior)

In pass-by-value, the function receives a copy of the array's address. This means that any changes made within the function do not affect the original array outside the function. To demonstrate this, let's create an example function that takes an array and sorts its elements in ascending order:

void sortArray(int arr[], int size) {
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}

int main() {
int arr[] = {5, 3, 1, 4, 2};
sortArray(arr, sizeof(arr) / sizeof(arr[0]));
// The sorted array is printed here
return 0;
}

In this example, the sortArray() function receives a copy of the arr array's address. Although it sorts the elements within the function, the original array remains unchanged:

int main() {
int arr[] = {5, 3, 1, 4, 2};
sortArray(arr, sizeof(arr) / sizeof(arr[0]));
printf("Original Array: ");
for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
printf("%d ", arr[i]);
}
// Output: Original Array: 5 3 1 4 2
}

Pass-by-Reference (Using Pointers)

To achieve pass-by-reference in C, we can use pointers. By passing the address of an array to a function, any changes made within the function will affect the original array outside the function. To demonstrate this, let's create a new version of the sortArray() function that sorts the array using pass-by-reference:

void sortArrayPtr(int *arr, int size) {
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}

int main() {
int arr[] = {5, 3, 1, 4, 2};
sortArrayPtr(arr, sizeof(arr) / sizeof(arr[0]));
printf("Sorted Array: ");
for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
printf("%d ", arr[i]);
}
// Output: Sorted Array: 1 2 3 4 5
}

In this example, the sortArrayPtr() function receives a pointer to the first element of the array. Any changes made within the function will affect the original array outside the function:

int main() {
int arr[] = {5, 3, 1, 4, 2};
sortArrayPtr(arr, sizeof(arr) / sizeof(arr[0]));
printf("Original Array: ");
for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
printf("%d ", arr[i]);
}
// Output: Original Array: 1 2 3 4 5
}

Worked Example

Let's create a function that calculates the sum of all elements in an array using both pass-by-value and pass-by-reference:

int sumArray(int arr[], int size) { // Pass-by-value
int total = 0;
for (int i = 0; i < size; i++) {
total += arr[i];
}
return total;
}

void sumArrayPtr(int *arr, int size) { // Pass-by-reference
int total = 0;
for (int i = 0; i < size; i++) {
total += arr[i];
}
printf("Sum using pass-by-reference: %d\n", total);
}

int main() {
int arr[] = {1, 2, 3, 4, 5};
int sumVal = sumArray(arr, sizeof(arr) / sizeof(arr[0])); // Pass-by-value
printf("Sum using pass-by-value: %d\n", sumVal);
sumArrayPtr(arr, sizeof(arr) / sizeof(arr[0])); // Pass-by-reference
return 0;
}

Output:

Sum using pass-by-value: 15
Sum using pass-by-reference: 15

Common Mistakes

Forgetting the Size Parameter

When passing an array to a function, always include a size parameter to ensure that the function knows how many elements to process.

Incorrect Function Prototype

Ensure that the function prototype matches the actual implementation, including the correct data type for the array and the size parameter.

Using Pass-by-Value with Large Arrays

Using pass-by-value with large arrays can lead to performance issues due to the copying of array data. In such cases, consider using pass-by-reference or dynamic memory allocation.

Practice Questions

1. Write a function that swaps two elements in an array using pass-by-reference.
2. Create a function that finds the maximum element in an array using both pass-by-value and pass-by-reference.
3. Given the following array arr[] = {5, 10, 15, 20, 25};, write a function that calculates and returns the average of every three consecutive elements using pass-by-value and pass-by-reference.

FAQ

Q: Why does C use pass-by-value by default when passing arrays to functions?

A: C uses pass-by-value for arrays because it is more straightforward to implement and less error-prone than pass-by-reference. However, this behavior can lead to unexpected results if we don't explicitly use pointers or understand the implications of pass-by-value for arrays.

Q: When should I prefer using pass-by-reference over pass-by-value when passing arrays to functions?

A: Use pass-by-reference with pointers when you want to modify the original array within the function and have those changes reflected outside the function. Pass-by-value is suitable for read-only operations or when we don't need to modify the original array.

Q: How can I avoid performance issues when using pass-by-value with large arrays?

A: To avoid performance issues, consider using dynamic memory allocation (e.g., malloc()) to create a new array within the function and process the original array element by element. This approach minimizes the need for copying large amounts of data.