• But design decisions should go beyond how data is stored; they should also involve how the data is used

Often, you’ll find it profitable to write specific functions to handle specific data operations

• (The profits here include increased program reliability, ease of modification, and ease of debugging.)
  • Also, when you begin integrating storage properties with operations when you think about a program, you are taking an important step toward the OOP mind-set; that, too, might prove profitable in the future

Let’s examine a simple case

• Suppose you want to use an array to keep track of the dollar values of your real estate
  • (If necessary, suppose you have real estate.)
    • You have to decide what type to use
      • Certainly, double is less restrictive in its range than int or long, and it provides enough significant digits to represent the values precisely

Next, you have to decide on the number of array elements

• (With dynamic arrays created with new, you can put off that decision, but let’s keep things simple.)
  • Let’s say that you have no more than five properties, so you can use an array of five doubles

Now consider the possible operations you might want to execute with the real estate array

• Two very basic ones are:
• Reading values into the array
• And displaying the array contents
• Let’s add one more operation to the list:
• Reassessing the value of the properties
• For simplicity, assume that all your properties increase or decrease in value at the same rate
• (Remember, this is a topic in C++, not on real estate management.)

Next, fit a function to each operation and then write the code accordingly

• We’ll go through the steps of creating these pieces of a program next
  • Afterward, we’ll fit them into a complete example

Filling the Array

Because a function with an array name argument accesses the original array, not a copy, you can use a function call to assign values to array elements

• One argument to the function will be the name of the array to be filled
  • In general, a program might manage more than one person’s investments, hence more than one array, so you don’t want to build the array size into the function
  • Instead, you pass the array size as a second argument
• Also, it’s possible that you might want to quit reading data before filling the array, so you want to build that feature in to the function
• Because you might enter fewer than the maximum number of elements, it makes sense to have the function return the actual number of values entered
  • These considerations suggest the following function prototype (A-1)

Example of (A-1)

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

The function takes an array name argument and an argument specifying the maximum number of items to be read, and the function returns the actual number of items read

• For example, if you use this function with an array of five elements, you pass 5 as the second argument
  • If you then enter only three values, the function returns 3

You can use a loop to read successive values into the array, but how can you terminate the loop early?

• One way is to use a special value to indicate the end of input
• Because no property should have a negative value, you can use a negative number to indicate the end of input
• Also, the function should do something about bad input
• Such as terminating further input
• Given this, you can code the function as follows (A-2):
• 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

Example of (A-2)

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;
		}
		else if (temp < 0) // signal to terminate
			break;
		ar[i] = temp;
	}
	return i;
}

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 when you declare the formal argument (A-3)
• 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 (A-4)
• 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) (A-5)
• 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 (A-6)

Example of (A-3)

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

Example of (A-4)

ar[0] += 10;

Example of (A-5)

Cannot modify a const object in function show_array(const double *,int)

Example of (A-6)

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 (A-7)
• Because this function is supposed to alter the array values, you don’t use const when you declare ar

Example of (A-7)

void revalue(double r, double ar[], int n)
{
	for (int i = 0; i < n; i++)
		ar[i] *= r;
}

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()
• Most of the remaining programming work consists of having main() call the functions you’ve just developed
• (A-8) shows the result
• It places a using directive in just those functions that use the iostream facilities

Example of (A-8)

// arrfun3.cpp -- array functions and const
#include <iostream>
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);
	cout << "Enter reassessment rate: ";
	double factor;
	cin >> factor;
	revalue(factor, properties, size);
	show_array(properties, size);
	cout << "Done.\n";
	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;
		}
		else if (temp < 0) // signal to terminate
			break;
		ar[i] = temp;
	}
	return i;
}
 
// the following function can use, but not alter,
// the array whose address is ar
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;
	}
}
 
// multiplies each element of ar[] by r
void revalue(double r, double ar[], int n)
{
	for (int i = 0; i < n; i++)
		ar[i] *= r;
}

Here are two sample runs of the program in (A-8):

Recall that fill_array() prescribes that input should quit when the user enters five properties or enters a negative number, whichever comes first

• The first output example illustrates reaching the five-property limit
• And the second output example illustrates that entering a negative value terminates the input phase

Program Notes

We’ve already discussed the important programming details related to the real estate example, so let’s reflect on the process

• You began by thinking about the data type and designed appropriate functions to handle the data
• Then, you assembled these functions into a program
• This is sometimes called bottom-up programming because the design process moves from the component parts to the whole
• This approach is well suited to OOP, which concentrates on data representation and manipulation first
• Traditional procedural programming, on the other hand, leans toward top-down programming
• In which you develop a modular grand design first and then turn your attention to the details
• Both methods are useful, and both lead to modular programs

• So let’s look at a couple examples along those lines

The first example deals with travel time (not to be confused with time travel)

• Some maps will tell you that
  • It is 2 hours, 56 minutes, from Zero One City to Binary Falls
  • And 1 hour, 16 minutes, from Binary Falls to Hexadecimal Valley

You can use a structure to represent such times

• Using one member for the hour value
• And a second member for the minute value

Adding two times is a little tricky

• Because you might have to transfer some of the minutes to the hours part
  • For example, the two preceding times sum to 3 hours, 72 minutes, which should be converted to 4 hours, 12 minutes

Let’s develop a structure to represent a time value

• And then a function that takes two such structures as arguments
  • And returns a structure that represents their sum

Defining the structure is simple (A-1):


Example of (A-1)

struct travel_time
{
	int hours;
	int mins;
};

Next, consider the prototype for a sum() function that returns the sum of two such structures

• The return value should be type travel_time, and so should the two arguments
  • Thus, the prototype should look like this (A-2):

Example of (A-2)

travel_time sum(travel_time t1, travel_time t2);

To add two times, you first add the minute members

• Integer division by 60 yields the number of hours to carry over
• And the modulus operation (%) yields the number of minutes left

(A-3) incorporates the above approach into the sum() function

• And adds a show_time() function
  • To display the contents of a travel_time structure

 


Example of (A-3)

// travel.cpp -- using structures with functions
#include <iostream>
struct travel_time
{
	int hours;
	int mins;
};
const int Mins_per_hr = 60;
 
travel_time sum(travel_time t1, travel_time t2);
void show_time(travel_time t);
 
int main()
{
	using namespace std;
	travel_time day1 = {2, 56}; // 2 hrs, 56 min
	travel_time day2 = {1, 16}; // 1 hrs, 16 min
 
	travel_time trip = sum(day1, day2);
	cout << "Two-day total: ";
	show_time(trip);
 
	travel_time day3= {5, 12};
	cout << "Three-day total: ";
	show_time(sum(trip, day3));
 
	return 0;
}
 
travel_time sum(travel_time t1, travel_time t2)
{
	travel_time total;
 
	total.mins = (t1.mins + t2.mins) % Mins_per_hr;
	total.hours = t1.hours + t2.hours +
		    (t1.mins + t2.mins) / Mins_per_hr;
	return total;
}
 
void show_time(travel_time t)
{
	using namespace std;
	cout << t.hours << " hours, "
	     << t.mins << " minutes\n";
}

Here travel_time acts just like a standard type name; you can use it to

• Declare variables
• Function return types
• Function argument types

Because variables such as total and t1 are travel_time structures

• You can apply the dot membership operator to them

Note that because the sum() function returns a travel_time structure

• You can use it as an argument for the show_time() function

Because C++ functions, by default, pass arguments by value

• The show_time(sum(trip, day3)) function call
• First evaluates the sum(trip, day3) function call in order to find its return value
• The show_time() call
• Then passes sum()’s return value, not the function itself to show_time()

Here’s the output of the program in (A-3):

• Instructions can be treated as assignments

Assignment will be…

• Called a function

The primary function used in C++

• Is called main

Function’s name is

• Followed by an opening and a closing parentheses

Main function will always be written

• At least as main()

When a program is written and you ask the computer to “execute” it, the first thing to look for

• Is the main() function
• This means that every C++ program should have the main() function

Function has

• A body; this is where the behavior (assignment) of the function would be “described”

 


The body of a function

• Starts with an opening curly bracket “{” and closes with a closing curly bracket “}“
• Everything in the curly brackets belongs to, or is part of, the function

The main() function can be written as (A-1):


Example of (A-1)

main(){}

Whenever you create a program

• It is important to isolate any inclusion of a library on its own line (A-2)

Example of (A-2)

#include <iostream>
using namespace std;
main(){}