# Using Arrays with Functions

We have read the students' scores into an array, and now we want to write a function to compute something useful about the data, say the maximum score. To do this, we will need to pass the array to the function as an argument. Here is the prototype for a max() function:

int max(int data[], int dataLen); Note that in this case it is not necessary to provide the length of the array parameter (int data[]) since we are providing the number of elements in the parameter dataLen. When passing an array in this fashion, the function knows where in memory the array starts, but not it's length; the dataLen parameter is necessary to indicate the length.

Within the max() function, we can access the array data[] using square brackets as we would any other array. Computing the maximum value is simple:

int max(int data[], int dataLen) { int currentMax = data[0]; for (int i = 1; i < dataLen; i++) { if (data[i] > currentMax) { currentMax = data[i]; } } return currentMax; } The following code demonstrates how to call the max() function: const int NUM_STUDENTS = 100; int scores[NUM_STUDENTS] = { 0 }; int numScores = 0; // Code to read scores... int maxVal = max(scores, numScores); // compute max score When passing an array as an argument, we only provide the name of the array (scores in this example). The compiler knows that scores is really an array since it was declared that way in the function prototype. Technically, what is really being passed to the function is the address in memory of the first element of the scores[] array.

Note: the implementation of the maximum function given above assumes there is at least one item in the data[] array. How would you modify the function to handle the case in which data[] is empty?

There is an important difference between array parameters and primitive parameters: a function can modify the values in an array whereas it cannot modify the value of an argument of primitive type (primitive types are the basic types proided by C++, e.g. int, char, float, etc.). For example, the following function, curve(), adds five to each element of the data[] array:

void curve(int data[], int dataLen) { while (dataLen-- > 0) data[dataLen] += 5; } If we call this function with our scores[] array as the argument, each score will be increased by five points, and this change will be visible in the calling function. However, the changes to dataLen will not be visible to the calling function since it is a parameter of type int, which is a primitive type.