7.8.1. Linear Array Example: average.cpp

The following programs add linear a array to practice problems introduced in the previous chapter. Linear arrays have one dimension, so they look like a list or a single line of elements. The programs demonstrate how to define an array and access its elements with an index (or subscript). They illustrate a series of programs forming a stepwise development of a program that reads a variable number of values from the console and stores them in an array. The series also creates a reusable function that calculates the average (mean) of the values stored in the array. The first two programs fill the array with a fixed number of pseudo-random values¹. The third program organizes the demonstration into its final, more authentic form: a client allowing a user to enter an indeterminate number of values - ostensibly assignment scores - through the console, and a supplier function that calculates the average.

Although generating pseudo-random numbers is a distraction from the primary purpose of the examples (demonstrating fundamental array syntax), it allows the initial programs to focus on arrays with little regard to the source of the stored values. The generating process uses object-oriented and operator-overloading features introduced in subsequent chapters. Consequently, the text only briefly describes them. The optional video and footnote provide a general background for the interested reader.

Array Averaging Program 1

#include <iostream>
#include <random>								(a)
#include <chrono>
#include <time.h>
using namespace std;

int main()
{
    long ticks = chrono::system_clock::now().time_since_epoch().count();	(b)

    default_random_engine            rng((unsigned)(ticks));			(c)
    uniform_int_distribution<int>    range(1, 100);				(d)

    int    numbers[10];								(e)

    for (int i = 0; i < 10; i++)						(f)
        numbers[i] = range(rng);

    double    sum = 0;								(g)

    for (int i = 0; i < 10; i++)						(h)
        sum += numbers[i];

    cout << "The average is " << sum / 10 << endl;				(i)

    return 0;
}

Array Averaging Program 2

The second version of the program moves the averaging operations - steps (g) and (h) in the previous figure - to an average function, demonstrating passing a one-dimensional array as a function argument. The example illustrates two significant aspects of passing arrays as function arguments:

1. By default, C++ passes most data types to functions by value. Arrays are the exception to this rule - C++ always passes arrays by-pointer. The example shows two versions of the function prototype and the function header. The different versions are equivalent, and programs only need one of them.
2. Only the array's name appears in the function call because the name, without the square brackets, is a pointer - the array's address.

#include <iostream>
#include <random>
#include <chrono>
using namespace std;

double average(int* numbers);							// (a)

int main()
{
    default_random_engine
        rng((unsigned)(chrono::system_clock::now().time_since_epoch().count()));
    uniform_int_distribution<int>	range(1, 100);

    int	numbers[10];

    for (int i = 0; i < 10; i++)
        numbers[i] = range(rng);

    cout << "The average is " << average(numbers) << endl;			// (b)

    return 0;
}

double average(int* numbers)							// (c)
{
    double	sum = 0;							// (d)

    for (int i = 0; i < 10; i++)						// (e)
        sum += numbers[i];

    return sum / 10;								// (f)
}

Array Averaging Program 3

Making the averaging operation a function and generalizing it allows programs to calculate averages wherever a program needs that functionality. However, C++ implements arrays as contiguous blocks of memory and manipulates them as pointers. Arrays are not objects and do not intrinsically maintain their size (the number of filled elements) nor their capacity (total available elements). Consequently, C++ programs must maintain these values as discrete variables. (C++ does have a more-capable array class, but, like the pseudo-random number generator, it relies on concepts introduced later in the text.) The primary generalizing task is to provide the function with the array size, but we also change the function parameter names as described below.

#include <iostream>
using namespace std;

double average(int size, int* a);					// (a)

int main()
{
    int	scores[1000];							// (b)
    int	count  = 0;							// (c)

    while (count < 1000)						// (d)
    {
        int	score;
        cout << "Please enter a score: ";
        cin >> score;
        if (score != -1)						// (e)
            scores[count++] = score;					// (f)
        else
            break;
    }

    if (count == 1000)							// (g)
        cout << "The number of entered scores exceeds 1000" << endl;

    cout << "The average is " << average(count, scores) << endl;	// (h)

    return 0;
}

double average(int size, int* a)					// (a)
{
    if (size == 0)							// (b)
    {
        cerr << "Array is empty" << endl;
        return 0;
    }

    double sum = 0;

    for (int i = 0; i < size; i++)
        sum += a[i];

    return sum / size;							// (c)
}

1. Pseudo-random numbers are not random - they arise from deterministic calculations - but look random (i.e., pass some statistical tests of randomness). Pseudo-random number generators produce a long cycle of numbers (i.e., a sequence of numbers that eventually repeats) using a recurrence relation: R_n = f(R_n-1). Programs typically use only a small part of the cycle, which increases the random appearance. Programs start a random number generator at some point in the cycle by specifying a "seed" value: an initial R_i.

   Pseudo-random number generators frequently use the computer's clock to get the elapsed time since the epoch. The elapsed time is a monotonically increasing value - it remains unchanged between clock "ticks" but never decreases - making it an effective, low-cost seed value. Some generators can produce various distributions - a value's frequency of occurrence in a given range. The values in a uniform distribution are equally likely.

   Please see the optional Random Number Generators video at the top for more detail.