C++ Primer Plus

Note that this code includes a prompt to the user. If the user enters a non-negative value, the value is assigned to the array. Otherwise, the loop terminates. If the user enters only valid values, the loop terminates after it reads limit values. The last thing the loop does is increment i, so after the loop terminates, i is one greater than the last array index, hence it’s equal to the number of filled elements. The function then returns that value.

Showing the Array and Protecting It with const

Building a function to display the array contents is simple. You pass the name of the array and the number of filled elements to the function, which then uses a loop to display each element. But there is another consideration—guaranteeing that the display function doesn’t alter the original array. Unless the purpose of a function is to alter data passed to it, you should safeguard it from doing so. That protection comes automatically with ordinary arguments because C++ passes them by value, and the function works with a copy. But functions that use an array work with the original. After all, that’s why the fill_array() function is able to do its job. To keep a function from accidentally altering the contents of an array argument, you can use the keyword const (discussed in Chapter 3, “Dealing with Data”) when you declare the formal argument:

void show_array(const double ar[], int n);

The declaration states that the pointer ar points to constant data. This means that you can’t use ar to change the data. That is, you can use a value such as ar[0], but you can’t change that value. Note that this doesn’t mean that the original array needs be constant; it just means that you can’t use ar in the show_array() function to change the data. Thus, show_array() treats the array as read-only data. Suppose you accidentally violate this restriction by doing something like the following in the show_array() function:

ar[0] += 10;

In this case, the compiler will put a stop to your wrongful ways. Borland C++, for example, gives an error message like this (edited slightly):

Cannot modify a const object in function

       show_array(const double *,int)

Other compilers may choose to express their displeasure in different words.

The message reminds you that C++ interprets the declaration const double ar[] to mean const double *ar. Thus, the declaration really says that ar points to a constant value. We’ll discuss this in detail when we finish with the current example. Meanwhile, here is the code for the show_array() function:

void show_array(const double ar[], int n)

{

    using namespace std;

    for (int i = 0; i < n; i++)

    {

         cout << "Property #" << (i + 1) << ": $";

         cout << ar[i] << endl;

    }

}

Modifying the Array

The third operation for the array in this example is multiplying each element by the same revaluation factor. You need to pass three arguments to the function: the factor, the array, and the number of elements. No return value is needed, so the function can look like this:

void revalue(double r, double ar[], int n)

{

      for (int i = 0; i < n; i++)

            ar[i] *= r;

}

Because this function is supposed to alter the array values, you don’t use const when you declare ar.

Putting the Pieces Together

Now that you’ve defined a data type in terms of how it’s stored (an array) and how it’s used (three functions), you can put together a program that uses the design. Because you’ve already built all the array-handling tools, you’ve greatly simplified programming main(). The program does check to see if the user responds to the prompt for a revaluation factor with a number. In this case, rather than stopping if the user fails to comply, the program uses a loop to ask the user to do the right thing. Most of the remaining programming work consists of having main() call the functions you’ve just developed. Listing 7.7 shows the result. It places a using directive in just those functions that use the iostream facilities.

Listing 7.7. arrfun3.cpp

// arrfun3.cpp -- array functions and const

#include

const int Max = 5;

// function prototypes

int fill_array(double ar[], int limit);

void show_array(const double ar[], int n);  // don't change data

void revalue(double r, double ar[], int n);

int main()

{

    using namespace std;

    double properties[Max];

    int size = fill_array(properties, Max);

    show_array(properties, size);

    if (size > 0)

    {

        cout << "Enter revaluation factor: ";

        double factor;

        while (!(cin >> factor))    // bad input

        {

            cin.clear();

            while (cin.get() != '\n')

                continue;

           cout << "Bad input; Please enter a number: ";

        }

        revalue(factor, properties, size);

        show_array(properties, size);

    }

    cout << "Done.\n";

    cin.get();

    cin.get();

    return 0;

}

int fill_array(double ar[], int limit)

{

    using namespace std;

    double temp;

    int i;

    for (i = 0; i < limit; i++)

    {

        cout << "Enter value #" << (i + 1) << ": ";

        cin >> temp;

        if (!cin)    // bad input

        {

            cin.clear();

            while (cin.get() != '\n')

                continue;

           cout << "Bad input; input process terminated.\n";

           break;