Array as Function Parameters in C++

In C++, arrays are frequently used to handle collections of data. Passing arrays to functions is a common practice, but understanding how arrays are passed and how they can be modified inside a function is crucial for writing efficient and error-free programs. This post will explore the process of passing arrays to functions in C++ and how the behavior of arrays as function parameters works in practice.

Overview of Passing Arrays to Functions

When passing an array to a function in C++, it is important to know that arrays are always passed by reference. This means that rather than copying the entire array, only the address (or pointer) of the first element is passed to the function. Consequently, any changes made to the array elements within the function will affect the original array in the calling function.

In this post, we will discuss how arrays are passed to functions, how they behave inside functions, and how you can modify them directly.

Topics to Cover:

• Passing Arrays to Functions
• How Arrays Are Passed by Reference
• Modifying Arrays Inside Functions
• Example of Passing an Array to a Function

---

Passing Arrays to Functions

In C++, arrays are passed to functions by reference by default. When you pass an array to a function, what you are actually passing is the address of the first element of the array. This is why modifications made to the array within the function directly affect the original array.

Syntax to Pass Arrays

The syntax for passing an array to a function is similar to how you declare arrays. You specify the name of the array along with its size in the function prototype. However, you can omit the size in the function definition and just specify the type of the array.

Function Declaration and Definition:

void modifyArray(int arr[], int size);  // Function declaration

void modifyArray(int arr[], int size) {  // Function definition
// Function body
}

Example: Passing an Array to a Function

#include <iostream>
using namespace std;

void modifyArray(int arr[], int size) {
for (int i = 0; i &lt; size; i++) {
    arr&#91;i] *= 2;  // Modifying array elements
}
}

int main() {
int arr&#91;3] = {1, 2, 3};
modifyArray(arr, 3);  // Passing array to function
// Printing modified array
for (int i = 0; i &lt; 3; i++) {
    cout &lt;&lt; arr&#91;i] &lt;&lt; " ";
}
return 0;
}

Output:

2 4 6

In the above example:

• The arr[] parameter in the function modifyArray is passed by reference, meaning that the changes made inside the function affect the original array.
• The function multiplies each element by 2, modifying the original array.

---

How Arrays Are Passed by Reference

In C++, when you pass an array to a function, you are not passing the entire array. Instead, you are passing a pointer to the first element of the array. This is why arrays are always passed by reference, even though the syntax might seem like you’re passing a copy.

Reference vs. Value Passing

• Passing by reference: When you pass an array to a function, the function receives the memory address of the first element of the array. As a result, any modification to the array in the function will directly affect the original array.
• Passing by value: If you pass a variable by value, the function gets a copy of the variable, and changes made to the variable inside the function will not affect the original variable.

Since arrays are passed by reference, the original array in the calling function is directly modified when you modify the array inside the function.

---

Modifying Arrays Inside Functions

Because arrays are passed by reference in C++, any changes made to an array inside a function will affect the original array. You can modify the array elements by simply referencing them via their index.

For example, you can loop through the array and modify its elements, as shown in the modifyArray function in the earlier example.

Key Points:

• Any modification to array elements inside a function reflects in the original array because the function operates on the array via a reference (pointer).
• You can use loops to iterate through the array and modify the elements based on certain conditions.

Example of Modifying Array Elements Inside a Function:

#include <iostream>
using namespace std;

void squareArray(int arr[], int size) {
for (int i = 0; i &lt; size; i++) {
    arr&#91;i] = arr&#91;i] * arr&#91;i];  // Squaring each element of the array
}
}

int main() {
int arr&#91;5] = {1, 2, 3, 4, 5};
squareArray(arr, 5);  // Passing array to function
// Printing modified array
for (int i = 0; i &lt; 5; i++) {
    cout &lt;&lt; arr&#91;i] &lt;&lt; " ";
}
return 0;
}

Output:

1 4 9 16 25

In this example:

• The squareArray function squares each element of the array.
• Since arrays are passed by reference, the changes are reflected in the original array.

---

Array Size and Function Parameters

When passing arrays to functions, it is crucial to provide information about the size of the array since the function does not automatically know the size of the array. You can pass the size of the array as a separate parameter.

This is why the size parameter is passed to the modifyArray function in the earlier examples. The size of the array is required to properly loop through and modify the array.

Example:

#include <iostream>
using namespace std;

void printArray(int arr[], int size) {
for (int i = 0; i &lt; size; i++) {
    cout &lt;&lt; arr&#91;i] &lt;&lt; " ";
}
}

int main() {
int arr&#91;4] = {10, 20, 30, 40};
printArray(arr, 4);  // Passing the array and its size
return 0;
}

Output:

10 20 30 40

In this example, the function printArray prints the elements of the array. The size of the array is passed to the function so it can loop through the correct number of elements.

---

Using Arrays in Functions with Dynamic Size

If the size of the array is not known at compile time, you can use dynamic memory allocation to create arrays with a size determined at runtime. This approach is useful when dealing with large arrays or when the array size is not fixed.

To dynamically allocate an array, you can use the new keyword, and deallocate the memory with delete[] when you’re done with the array.

Example: Dynamic Array Allocation

#include <iostream>
using namespace std;

void doubleArray(int* arr, int size) {
for (int i = 0; i &lt; size; i++) {
    arr&#91;i] *= 2;  // Doubling each element
}
}

int main() {
int size;
cout &lt;&lt; "Enter the size of the array: ";
cin &gt;&gt; size;
// Dynamically allocating the array
int* arr = new int&#91;size];
// Initializing the array with user input
for (int i = 0; i &lt; size; i++) {
    arr&#91;i] = i + 1;  // Initializing array elements
}
// Passing the array to the function
doubleArray(arr, size);
// Printing the modified array
cout &lt;&lt; "Modified array: ";
for (int i = 0; i &lt; size; i++) {
    cout &lt;&lt; arr&#91;i] &lt;&lt; " ";
}
// Deallocating the array
delete&#91;] arr;
return 0;
}

Example Output:

Enter the size of the array: 4
Modified array: 2 4 6 8

In this case:

• We dynamically allocate an array based on user input.
• After modifying the array in the doubleArray function, we deallocate the memory using delete[].