Lab 12 -- One-dimensional Arrays

In this lab we will introduce the array, a homogeneous data construct used to represent a group of data where each element of the group is of the same data type. This data construct might be used to store many items of the same type as a conceptual unit. For example, all of the scores made on a test by students in a biology class might be stored in an array, or the names of students in a biology class might be stored in an array.

(In another lab we will learn about two other C++ composite data constructs, the struct and the class, that can be used to represent heterogeneous groups of data. These two data constructs are used to store many data items of different types as a conceptual unit. For example, the struct or class could be used to store information about a student -- like name, classification, etc. . )

       int x;
          .
          .
       x = 25;

instruct the computer to set aside a memory location that will hold an integer, giving the memory location the symbolic name x. The second statement instructs the computer to store the integer 25 in the memory location with the symbolic name x.

How can we store twenty integers in memory? We could dream up twenty different symbolic names, such as x1, x2, x3, ..., x20, for twenty places in memory. Obviously, this is not convenient. C++ has a data type called an array that addresses this particular problem.

An array, then is a group of locations in memory such that a) the locations are usually consecutive, b) all of these locations will contain the same type of data, and c) all of these locations are referenced by the same symbolic name.

Arrays are used anytime we wish to store and manipulate more than a few pieces of data of the same type. Consider the following examples:

1. Suppose that we wish to compute the average pay for 30 people. We do not require an array for this application, since we do not need to remember the data for all 30 people. In this problem we input data for one person and add it to an accumulator. We can use the same variable for the next person, since we no longer need to remember data for the previous person.
2. Suppose we wish to print out 30 scores in reverse order. We need an array for this application because we must remember all 30 numbers in order to print them out in reverse.

        const int MAX_SCORES = 30;
        int scores[MAX_SCORES];

Note the use of the constant MAX_SCORES for the upper limit on the size of the array. Using a const value to denote the size of the array is not required but is good programming practice. This code causes 30 locations in memory to be set aside under the name scores where each location (aka element) is of the data type int. This array, scores, can hold up to 30 integer values. (We sometimes use the term extent to refer to how many elements an array can store. In this example, because MAX_SCORES is set to 30, the extent of the scores array is 30.) It is said to be one-dimensional because it uses only one set of square brackets [ ] in its declaration.

      void ReadInScores (ifstream& ins, int scores[], int& howMany)
      {
           //read the number of scores
           ins >> howMany;

           //now read the scores
           for (int i = 0; i < howMany; i++)
           {
                ins >> scores[i];
           }

      }

Note: When an array is passed as an argument, we do not have to indicate the size of the array. Notice the empty brackets [] in the parameter list. These empty brackets [] tell the compiler that scores is an array of int rather than just a simple int.

WARNING 1: All arrays in C++ are pass-by-reference when used as function parameters. This means that when an array appears in the argument list of an activation statement (aka calling statement), the address of the array is sent to the function, not the contents of the array! Therefore, the array in the parameter list will be an alias (will refer to) to the same array as the argument.

WARNING 2: Use the reserve word const in the parameter list if an array is used and the contents of the array should NOT be altered. As an example, consider the following function header:

     void PrintScores(const int scores[], int howMany)

The values in the array scores can not be change in the PrintScores() function because we have used const in the parameter list. Therefore, we can protect the contents of the array by using const.

In a main program, we might have the following statements to declare an array and to use the functions above to read values into the array and print them.

    const int MAX_SCORES = 30;   //the array has at most 30 entries
    int scores [MAX_SCORES];     //an array of test scores with 30 entries
    int howMany;                 //the actual size of the array
    ifstream ins;                //the input file stream containing scores

    //open the input file
    ins.open("scores.dat");

    //call the function to read the scores
    ReadInScores(ins, scores, howMany);


    //call the function to print the scores
    PrintScores(scores, howMany);

Notice that when an array appears as an argument in a call statement, only the name of the array is needed. It would be an error to place the brackets after the array name in the argument list.