as Arrays Arguments in Functions
1
Arrays as Arguments in Functions
Any individual element (indexed variable) or the full array itself can be used as an argument in function calls. Array elements as arguments Any array element, such as score[2], can be an argument to a function in exactly the same way that any variable can be an argument. For example, if void exampleFunction(int); // function prototype is a void function that takes an int argument, then any element of an int type array can be used as an argument in the function call as follows. exampleFunction(score[2]); // function call In general, if i is a valid index (that is, within the array bounds), we can make a function call like this. exampleFunction(score[i]); // function call Depending on the value of i, the corresponding array element score[i] is taken as the argument.
Arrays as Arguments in Functions
2
To illustrate this, let us consider the following program. This program uses an array of char type in the main function. The letters in the array are converted to uppercase, one character at a time, using the function changeLetterToUpper. #include<iostream> #include<cctype> using namespace std; void changeLetterToUpper( char &); // function declaration // converts a given character to uppercase void main() { char message[5] = {'h', 'E', 'l', 'L', 'o'}; int i; cout << "Original message in the character array = "; for (i = 0; i < 5; i++) { cout << message[i]; } for (i = 0; i < 5; i++) { changeLetterToUpper( message[i] ); // function call } cout << endl << "Changed message in the character array = "; for (i = 0; i < 5; i++) { cout << message[i]; } cout << endl; } // end main function // function definition void changeLetterToUpper( char &ch) { ch = toupper(ch); } // end function changeLetterToUpper Output of the above program.
Original message in the character array = hElLo Changed message in the character array = HELLO
Arrays as Arguments in Functions
3
Though the program is very simple, it does illustrate how array elements are used as arguments to functions. Note that we supplied one array element at a time to the function changeLetterToUpper. Moreover, we did use the pass by reference method to do so, because we want to change the argument that is passed to the function. We can also pass array elements to functions using the pass by value method exactly the same way. Full array as an argument A function's formal parameter can be an array. As an example, we rewrite the changeLetterToUpper of our previos program, so that the function takes the array as an argument instead of a single element. The declaration for this function is as follows. void changeArrayToUpper( char a[ ], int size); This function will take two arguments. The first one is an array of base type char. We arbitrarily named this paramater as a, it is only a place holder. However the square braces [ ] that follow the name of the parameter is important. These braces notify the compiler that the parameter type is an array of type char, but not a single variable of type char. The second parameter is an int type, and we named it as size. This provides the size (number of elements) information of the array to the function. The size of the array is important. When we access an element of the array, it is this size we use to figure out whether we are within the valid bounds of the array or not.
Arrays as Arguments in Functions
4
Here is the rewritten version of our previos program. In this version, we supply the full array itself for conversion to uppercase. #include<iostream> #include<cctype> using namespace std; void changeArrayToUpper( char [], int); // function declaration // converts letters in the array to uppercase void main() { char message[5] = {'h', 'E', 'l', 'L', 'o'}; int i; cout << "Original message in the character array = "; for (i = 0; i < 5; i++) { cout << message[i]; } changeArrayToUpper( message, 5 ); // function call cout << endl << "Changed message in the character array = "; for (i = 0; i < 5; i++) { cout << message[i]; } cout << endl; } // end main function // function definition void changeArrayToUpper( char a[], int size) { for (int i = 0; i < size; i++) { a[i] = toupper( a[i] ); } } // end function changeArrayToUpper Output of the above program.
Original message in the character array = hElLo Changed message in the character array = HELLO
Arrays as Arguments in Functions
5
The parameter - char a[ ] In the function changeArrayToUpper, the parameter char a[] is an array parameter. It is the square braces that specify a is an array parameter and the type char indicates that each element of the array is a variable of type char. An array parameter is not really a pass by reference parameter, but in the above program it behaves like one. For now, we can think of the formal parameter char a[] as follows. When the following function call is made changeArrayToUpper(message, 5); the function treats as if its formal parameter a is replaced with the corresponding argument message. Thus, if an array is used as an argument in a function call, any action that is performed on the array parameter is performed on the array argument itself, so the values of the elements of the array argument get changed by the function. So far it seems that an array parameter is like a pass by reference parameter. However, that is not the case. Indeed, we passed the address of the array using pass by value method. We will look into it in more detail and understand its behavior later when we discuss another important variable type called a pointer type. The parameter - int size When an array argument is passed to the corresponding formal parameter char a[], the function knows that the variable a has to be treated as an array of type char. However, the array argument does not tell the function the size of the array. It has no knowledge of how many indexed variables (elements) the array has. Therefore it is essential that we must always have another int parameter the in function to specify the size of the array. It is this parameter, (in our example function size), the function uses to figure out whether we are within the valid bounds of the array or not. Arrays as arguments in function calls: Let us look at the function call we made in the program. changeArrayToUpper( message, 5 ); // function call Notice that we did not use the square braces for the array message. When an array argument is supplied for an array parameter, all that is given to the function is the address in memory of the first indexed variable of the array argument (the one indexed by 0). We discuss more on this when we introduce the pointer types.
Arrays as Arguments in Functions
6
Let us consider another example problem that uses an array of base type double. The program is supposed to accomplish the following. Step 1. Set a constant, say ARRAY_SIZE, to the required number of cells. Step 2. Create an array having ARRAY_SIZE elements of type double. Step 3. Get the input values from a file and fill the array elements. // The subtask in Step 3 to be executed by a function. Step 4. Output the values of array elements to an output file. Step 5. Compute and output to the file the average of the values. // The subtasks in Steps 4 and 5 to be executed by a function. We can code the above procedure as follows. #include<fstream> using namespace std; const int ARRAY_SIZE = 5; // Global declaration - Step 1 implementation
void fillArray( double [] ); // function declaration // fills the array elements reading data from file void outputResults( double [] ); // function declaration // outputs to a file the array element values and the average void main() { double myArray[ARRAY_SIZE]; // Step 2 implementation fillArray(myArray); // function call - Step 3 implementation outputResults(myArray); // function call - Steps 4 & 5 implementation } // end main function // function definitions void fillArray( double a[] ) { ifstream in("input.dat"); for (int i = 0; i < ARRAY_SIZE; i++) in >> a[i]; } // end function fillArray
Arrays as Arguments in Functions void outputResults( double a[] ) { ofstream out("output.dat"); out << "The "<< ARRAY_SIZE << " array elements are:" << endl; for (int i = 0; i < ARRAY_SIZE; i++) { out << a[i] << endl; } double sum = 0., ave; for (i = 0; i < ARRAY_SIZE; i++) { sum = sum + a[i]; } ave = sum / ARRAY_SIZE; out << "The average of array element values is : " << ave << endl; } // end function outputResults If the input file input.dat contains the following 22.2 35.4 18.8 199.4 33.6 then the output file output.dat produced by the program will be as follows. The 5 array elements are: 22.2 35.4 18.8 199.4 33.6 The average of array element values is : 61.88
7
Global scope of variables and constants In the programs we have described so far, all variables and constants have been local to the function in which they were defined. In the above program, we declared an integer constant ARRAY SIZE. This declaration is placed at the beginning, after the program's include statements and before the declarations of functions. It is important to note that the identifier ARRAY SIZE is not defined within a function. Such declarations are called global declarations. When we make a declaration globally, it is accessible by all functions defined after that declaration. Since we declared ARRAY SIZE in global scope, the constant is visible and accessible to all functions in the program. However, we did not declare the input file variable in or the ouput file variable out globally; instead we made these variable local to the functions in which they are used. Good C++ programmers seldom use global declarations, because it is not considered a good programming style. Moreover, global variables can make a program harder to understand and maintain, so we should not use any global variables. Once we have more experience designing programs, we can completly eliminate or minimize the use of global variables.
Arrays as Arguments in Functions Let us rewrite our program so that ARRAY SIZE is no longer a global variable. #include<fstream> using namespace std; void fillArray( double [], int ); // function declaration // fills the array elements reading data from file void outputResults( double [], int ); // function declaration // outputs to a file the array element values and the average
8
void main() { const int ARRAY_SIZE = 5; // Local declaration - Step 1 implementation double myArray[ARRAY_SIZE]; // Step 2 implementation fillArray(myArray); // function call - Step 3 implementation outputResults(myArray); // function call - Steps 4 & 5 implementation } // end main function void fillArray( double a[], int size ) { ifstream in("input.dat"); for (int i = 0; i < size; i++) in >> a[i]; } // end function fillArray void outputResults( double a[], int size ) { ofstream in("output.dat"); out << "The "<< size << " array elements are:" << endl; for (int i = 0; i < size; i++) { out << a[i] << endl; } double sum = 0., ave; for (i = 0; i < size; i++) { sum = sum + a[i]; } ave = sum / size; out << "The average of array element values is : " << ave << endl; } // end function outputResults In the above program the integer constant ARRAY SIZE is local to the main function. Therefore, no other function can access this variable. So if a function needs it, we have to supply it to the function as an argument. That is the reason, why we had to modify the function headers of the two functions fillArray and outputResults so that they take an additional parameter of type int.
Arrays as Arguments in Functions Array returning functions
9
In order to design functions that return arrays, we need the pointer types. Such functions, indeed, return a pointer to the array. We will discuss returning a pointer to an array when we introduce the pointer types and understand the interaction between the arrays and pointers.