What is meant by passing array to a function?

Passing an array to a function in C allows you to send the elements of an array as arguments to a function. This means that you can manipulate the array or perform operations on its elements within the function.

When you pass an array to a function, you are actually passing a pointer to the first element of the array. This is because arrays decay into pointers when passed as function arguments. Therefore, the function receives a pointer to the array, allowing it to access and modify the original array in the calling code.

Passing an array to a function is useful for several reasons:

1. Modularity: It allows you to organize your code into smaller, reusable functions. By passing an array as an argument, you can encapsulate a specific operation or algorithm within a function, making your code more modular and easier to maintain.
2. Efficiency: By passing an array to a function, you avoid the need to make a copy of the entire array. Instead, you pass a pointer to the array, which is more efficient in terms of memory usage and execution time, especially when dealing with large arrays.
3. Array Manipulation: Functions can perform various operations on the array elements, such as sorting, searching, filtering, or modifying their values. By passing the array to a function, you can encapsulate these operations and apply them to different arrays without duplicating code.

Example:

#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 numbers[] = {1, 2, 3, 4, 5};
    int size = sizeof(numbers) / sizeof(numbers[0]);

    printf("Array before modification: ");
    printArray(numbers, size);

    // Modify the array
    for (int i = 0; i < size; i++) {
        numbers[i] *= 2;
    }

    printf("Array after modification: ");
    printArray(numbers, size);

    return 0;
}

Output:

Array before modification: 1 2 3 4 5
Array after modification: 2 4 6 8 10

Explanation:

In above example, the printArray function takes an array (arr) and its size (size) as arguments and prints all the elements of the array. The main function creates an array called numbers and passes it to printArray to display its elements. Later, the main function modifies the array by doubling each element, demonstrating how a function can manipulate an array passed as an argument.

Different methods of passing array to function in C:

1. Pass by Value:

In this method, the entire array is copied and passed to the function. Any modifications made to the array within the function will not affect the original array in the calling code.

void myFunction(int arr[10]) {
    // Code to manipulate the array
}

int main() {
    int numbers[10];
    myFunction(numbers);
    // Code after the function call
    return 0;
}

2. Pass by Pointer:

This method involves passing a pointer to the first element of the array. The function can then access and modify the original array using the pointer.

void myFunction(int* arr, int size) {
    // Code to manipulate the array
}

int main() {
    int numbers[10];
    myFunction(numbers, 10);
    // Code after the function call
    return 0;
}

3. Pass by Reference:

This method is achieved in C++ using references, but in C, it can be simulated by passing a pointer to the array using the address-of operator (&). This allows the function to modify the original array directly.

void myFunction(int (*arr)[10]) {
    // Code to manipulate the array
}

int main() {
    int numbers[10];
    myFunction(&numbers);
    // Code after the function call
    return 0;
}

4. Pass Array size separately:

In this approach, the size of the array is passed as a separate argument to the function along with the array itself. This can be useful when the array size is not fixed or known in advance.

void myFunction(int arr[], int size) {
    // Code to manipulate the array
}

int main() {
    int numbers[10];
    int size = 10;
    myFunction(numbers, size);
    // Code after the function call
    return 0;
}

Another Example on passing array to function:

This example demonstrates passing an array to a function, modifying it within the function, and returning the modified array:

#include <stdio.h>

// Function to double each element of the array
void doubleArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        arr[i] *= 2;
    }
}

// Function to create and return a dynamically allocated array
int* createArray(int size) {
    int* arr = malloc(size * sizeof(int));
    
    // Initialize array elements
    for (int i = 0; i < size; i++) {
        arr[i] = i + 1;
    }
    
    return arr;
}

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

    printf("Array before modification: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    // Pass the array to the function and modify it
    doubleArray(numbers, size);

    printf("Array after modification: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    // Create an array dynamically and return it
    int* dynamicArray = createArray(size);

    printf("Dynamically created array: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", dynamicArray[i]);
    }
    printf("\n");

    free(dynamicArray);  // Remember to free the dynamically allocated memory

    return 0;
}

Output:

Array before modification: 1 2 3 4 5 
Array after modification: 2 4 6 8 10 
Dynamically created array: 1 2 3 4 5 

Explanation:

In this example, the doubleArray function takes an array (arr) and its size (size) as arguments. It doubles each element of the array using a loop. The createArray function dynamically allocates an array of the given size, initializes its elements with consecutive numbers, and returns the array pointer.

In the main function:

• An array called numbers is defined with initial values {1, 2, 3, 4, 5}.
• The array is printed before modification.
• The doubleArray function is called, passing the numbers array and its size. The function modifies the array by doubling each element.
• The modified array is printed.
• The createArray function is called, passing the size of the numbers array. It dynamically allocates a new array and initializes its elements with consecutive numbers.
• The dynamically created array is printed.
• The memory allocated for the dynamically created array is freed using free() to avoid memory leaks.

The output shows the original array, the modified array after calling the doubleArray function, and the dynamically created array. It demonstrates how passing an array to a function allows for modifications to the original array and how a dynamically allocated array can be returned from a function.

Rules to be followed when passing and returning array to function in C:

When passing an array to a function in C,

1. Array size: It is not necessary to specify the size of the array in the function prototype. You can use an empty bracket [] or a pointer * to indicate that the parameter is an array.
2. Array decay: When an array is passed as an argument to a function, it decays into a pointer to its first element. The function receives a pointer, not a copy of the array.
3. Memory access: Be cautious about accessing array elements outside the bounds of the array within the function. C does not perform bounds checking, so it’s your responsibility to ensure that you don’t go beyond the valid indices of the array.

When returning an array from a function in C,

1. Dynamic memory allocation: If you want to return an array that was created within the function, you should dynamically allocate memory for the array using functions like malloc, calloc, or realloc. This ensures that the memory for the array persists even after the function returns.
2. Returning a pointer: When returning an array from a function, you need to return a pointer to the first element of the array. This is because you cannot return a whole array directly in C.
3. Lifetime of the returned array: If you allocate memory dynamically within a function and return the pointer to the array, it becomes the responsibility of the calling code to free the allocated memory using free when it is no longer needed. Failing to do so can result in memory leaks.
4. Scope of local arrays: It is not recommended to return a pointer to a local array declared within a function. Once the function returns, the local array goes out of scope, and the returned pointer will become invalid.

More: