Arrays Parameters to Functions

In C++, you can pass arrays as arguments to functions. When you pass an array to a function, what actually gets passed is a pointer to the first element of the array. This is often referred to as "pass-by-reference," meaning changes made to the array inside the function are reflected outside the function as well.

Passing an array as a parameter to a function in programming is like giving someone a list of items to work with. Let's break this down in simple terms:

The Array: Imagine you have a list of things, like groceries. In programming, this list is like an array, which is a collection of items (like numbers, characters, etc.) stored together.
Passing the Array: Now, suppose you need someone to check prices for each item on your grocery list. In programming, this is like passing your array (the grocery list) to a function. The function is like the person you've asked to check the prices.
The Function Works on the Array: When the function receives the array, it can work with all the items on the list. It can read them, modify them, or perform any other operations. In our analogy, it's like the person going through your grocery list and writing down each item's price.
Accessing Array Items in the Function: Inside the function, it accesses the array items in the same way you would - using their positions in the array (like "the 1st item, the 2nd item," and so on).
No Need for Separate Copies: One important thing to note is that when you pass an array to a function, you’re usually not passing a whole new copy of all the array’s elements. Instead, you’re passing the address where the array starts (like giving the person the location of your list on a table). This means the function can access and modify the actual items in the array, not just copies.
Efficiency: This way of passing arrays is efficient because it avoids the need to copy each item. It's like not having to write out a whole new grocery list for the person checking prices – you just let them use your existing list.

Passing an array as a parameter in programming is like handing over a list of items for a function to work on. The function can then perform tasks using the items in the array, just like someone can perform tasks using the items on your list.

Using Array Syntax in Function Parameters

Even though the array is passed as a pointer, C++ allows you to use array syntax in the function declaration to clarify that an array is expected. You can define a function like so:

void modifyArray(int arr[], int size) {
    // ...
}

Passing Multi-dimensional Arrays

For multi-dimensional arrays, you have to specify the sizes for all but the first dimension:

void modify2DArray(int arr[][5], int rows) {
    // ...
}

Constant Arrays as Parameters

If you don't want to modify the array within the function, you can specify it as a constant parameter:

void printArray(const int arr[], int size) {
    // ...
}

By using const, you make it explicit that the array should not be modified within the function. Remember, by default, arrays are passed by reference.

Example:

In this example, the function printArray takes an array and its size as parameters and prints out the elements of the array. The main function declares an array myArray and calculates its size. Then it calls printArray to print the elements of myArray.