• The kind of data in the array
• The location of the beginning of the array
• And the number of elements in the array

The traditional C/C++ approach to functions that process arrays

• Is to pass a pointer to the start of the array as one argument
  • And to pass the size of the array as a second argument
    • (The pointer tells the function both where to find the array and the kind of data in it.)
      • That gives the function the information it needs to find all the data

There is another approach to giving a function the information it needs: to specify a range of elements

• This can be done by passing two pointers
• One identifying the start of the array and one identifying the end of the array
• The C++ Standard Template Library, for example, generalizes the range approach
• The STL approach uses the concept of “one past the end” to indicate an extent
• That is, in the case of an array, the argument identifying the end of the array would be a pointer to the location just after the last element
• For example, suppose you have this declaration (A-1):
• Then the two pointers elboud and elboud + 20 define the range
• First, elboud, being the name of the array, points to the first element
• The expression elboud + 19 points to the last element (that is, elboud[19]), so elboud + 20 points to one past the end of the array
• Passing a range to a function tells it
• Which elements to process
• (A-2) use two pointers to specify a range

Example of (A-1)

double elbuod[20];

Example of (A-2)

// arrfun4.cpp -- functions with an array range
#include <iostream>
const int ArSize = 8;
int sum_arr(const int * begin, const int * end);
int main()
{
	using namespace std;
	int cookies[ArSize] = {1,2,4,8,16,32,64,128};
// some systems require preceding int with static to
// enable array initialization
 
	int sum = sum_arr(cookies, cookies + ArSize);
	cout << "Total cookies eaten: " << sum << endl;
	sum = sum_arr(cookies, cookies + 3); // first 3 elements
	cout << "First three eaters ate " << sum << " cookies.\n";
	sum = sum_arr(cookies + 4, cookies + 8); // last 4 elements
	cout << "Last four eaters ate " << sum << " cookies.\n";
	return 0;
}
 
// return the sum of an integer array
int sum_arr(const int * begin, const int * end)
{
	const int * pt;
	int total = 0;
	for (pt = begin; pt != end; pt++)
		total = total + *pt;
	return total;
}

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

Program Notes

In (A-2), notice the for loop in the sum_array() function (A-3)

• It sets pt to point to the first element to be processed (the one pointed to by begin) and adds *pt (the value of the element) to total
  • Then the loop updates pt by incrementing it, causing it to point to the next element
    • The process continues as long as pt != end
      • When pt finally equals end, it’s pointing to the location following the last element of the range, so the loop halts

Example of (A-3)

for (pt = begin; pt != end; pt++)
	total = total + *pt;

Second, notice how the different function calls specify different ranges within the array (A-4)

• The pointer value cookies + ArSize points to the location following the last element
• (The array has ArSize elements, so cookies[ArSize - 1] is the last element, and its address is cookies + ArSize – 1.)
• So the range cookies, cookies + ArSize specifies the entire array
• Similarly, cookies, cookies + 3 specifies the first three elements, and so on
• Note, by the way, that the rules for pointer subtraction imply that
• In sum_arr(), the expression end - begin is an integer value equal to the number of elements in the range

Example of (A-4)

int sum = sum_arr(cookies, cookies + ArSize);
...
sum = sum_arr(cookies, cookies + 3); // first 3 elements
...
sum = sum_arr(cookies + 4, cookies + 8); // last 4 elements

• 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

• The function call sum_arr(cookies, ArSize)
• Passes the address of the first element of the cookies array and the number of elements of the array to the sum_arr() function
• The sum_arr() function
• Assigns the cookies address to the pointer variable arr and assigns ArSize to the int variable n
• This means (A-1) doesn’t really pass the array contents to the function
• Instead, it tells the function where the array is (the address), what kind of elements it has (the type), and how many elements it has (the n variable)
• See (Image-1)
• Armed with this information, the function then uses the original array
• If you pass an ordinary variable, the function works with a copy
• But if you pass an array, the function works with the original
• Actually, this difference doesn’t violate C++’s pass-by-value approach
• The sum_arr() function still passes a value that’s assigned to a new variable
• But that value is a single address, not the contents of an array

Example of (A-1)

// arrfun1.cpp -- functions with an array argument
#include <iostream>
const int ArSize = 8;
int sum_arr(int arr[], int n); // prototype
int main()
{
	using namespace std;
	int cookies[ArSize] = {1,2,4,8,16,32,64,128};
// some systems require preceding int with static to
// enable array initialization
 
	int sum = sum_arr(cookies, ArSize);
	cout << "Total cookies eaten: " << sum << "\n";
	return 0;
}
 
// return the sum of an integer array
int sum_arr(int arr[], int n)
{
	int total = 0;
	for (int i = 0; i < n; i++)
		total = total + arr[i];
	return total;
}

(Image-1) Telling a function about an array

Is the correspondence between array names and pointers a good thing?

• Indeed, it is

The design decision to use array addresses as arguments saves the time and memory needed to copy an entire array

• The overhead for using copies can be prohibitive if you’re working with large arrays
• With copies, not only does a program need more computer memory, but it has to spend time copying large blocks of data
• On the other hand, working with the original data raises the possibility of inadvertent data corruption
• That’s a real problem in classic C, but ANSI C and C++’s const modifier provides a remedy
• You’ll soon see an example
• But first, let’s alter (A-1) to illustrate some points about how array functions operate

(A-2) demonstrates that cookies and arr have the same value

• It also shows how the pointer concept makes the sum_arr function more versatile than it may have appeared at first
  • To provide a bit of variety and to show you what it looks like, the program uses the std:: qualifier instead of the using directive to provide access to cout and endl

Example of (A-2)

// arrfun2.cpp -- functions with an array argument
#include <iostream>
const int ArSize = 8;
int sum_arr(int arr[], int n);
// use std:: instead of using directive
int main()
{
	int cookies[ArSize] = {1,2,4,8,16,32,64,128};
// some systems require preceding int with static to
// enable array initialization
 
	std::cout << cookies << " = array address, ";
// some systems require a type cast: unsigned (cookies)
 
	std::cout << sizeof cookies << " = sizeof cookies\n";
	int sum = sum_arr(cookies, ArSize);
	std::cout << "Total cookies eaten: " << sum << std::endl;
	sum = sum_arr(cookies, 3); // a lie
	std::cout << "First three eaters ate " << sum << " cookies.\n";
	sum = sum_arr(cookies + 4, 4); // another lie
	std::cout << "Last four eaters ate " << sum << " cookies.\n";
	return 0;
}
 
// return the sum of an integer array
int sum_arr(int arr[], int n)
{
	int total = 0;
	std::cout << arr << " = arr, ";
// some systems require a type cast: unsigned (arr)
	std::cout << sizeof arr << " = sizeof arr\n";
	for (int i = 0; i < n; i++)
		total = total + arr[i];
	return total;
}

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

Note that the address values and the array and integer sizes will vary from system to system

• Also, some implementations will display the addresses in base 10 notation instead of in hexadecimal

Program Notes

(A-2) illustrates some very interesting points about array functions

• First, note that cookies and arr both evaluate to the same address, exactly as claimed
• But sizeof cookies is 32, whereas sizeof arr is only 4
• That’s because sizeof cookies is the size of the whole array, whereas sizeof arr is the size of the pointer variable
• By the way, this is why you have to explicitly pass the size of the array rather than use sizeof arr in sum_arr()
• Because the only way sum_arr() knows the number of elements in the array is through what you tell it with the second argument, you can lie to the function
• For example, the second time the program uses the function, it makes this call (A-3)
• By telling the function that cookies has just three elements, you get the function to calculate the sum of the first three elements
• Why stop there? You can also lie about where the array starts (A-4)
• Because cookies acts as the address of the first element, cookies + 4 acts as the address of the fifth element
• This statement sums the fifth, sixth, seventh, and eighth elements of the array
• Note in the output how the third call to the function assigns a different address to arr than the first two calls did
• And yes, you can use &cookies[4] instead of cookies + 4 as the argument; they both mean the same thing

Example of (A-3)

sum = sum_arr(cookies, 3);

Example of (A-4)

sum = sum_arr(cookies + 4, 4);

Remember

• To indicate the kind of array and the number of elements to an array-processing function, you pass the information as two separate arguments (A-5)
  • Don’t try to pass the array size by using brackets notation (A-6)

Example of (A-5)

void fillArray(int arr[], int size); // prototype

Example of (A-6)

void fillArray(int arr[size]); // NO -- bad prototype

• C++ assigns an additional meaning to the & symbol
  • Presses it into service for declaring references
    • For example, to make rodents an alternative name for the variable rats, you could do the following (A-1):

Example of (A-1)

int rats;
int & rodents = rats; // makes rodents an alias for rats

In this context, & is not the address operator

• Instead, it serves as part of the type identifier
  • Just as char * in a declaration means pointer-to-char, int & means reference-to-int

 


The reference declaration allows you to use rats and rodents interchangeably; both refer to the same value and the same memory location

• (A-2) illustrates the truth of this claim

Example of (A-2)

// firstref.cpp -- defining and using a reference
#include <iostream>
int main()
{
	using namespace std;
	int rats = 255;
	int & rodents = rats; // rodents is a reference
 
	cout << "rats = " << rats;
	cout << ", rodents = " << rodents << endl;
	rodents++;
	cout << "rats = " << rats;
	cout << ", rodents = " << rodents << endl;
 
	// some implementations require type casting the following
	// addresses to type unsigned
 
	cout << "rats address = " << &rats;
	cout << ", rodents address = " << &rodents << endl;
	return 0;
}

Note that the & operator in the statement (A-3)

• Is not the address operator
  • But declares that rodents is of type int &—that is, it is a reference to an int variable

Example of (A-3)

int & rodents = rats;

But the & operator in the statement (A-4)

• Is the address operator
  • With &rodents representing the address of the variable to which rodents refers

Example of (A-4)

cout << ", rodents address = " << &rodents << endl;

Here is the output of the program in (A-2): 

As you can see both, rats and rodents have the same value and the same address

• (The address values and display format vary from system to system.)

 


Incrementing rodents by one, affects both variables

• More precisely, the rodents++ operation increments a single variable for which there are two names

Again, keep in mind that although this example shows you how a reference works

• It doesn’t represent the typical use for a reference, which is as a function parameter, particularly for structure and object arguments
  • We’ll look into these uses pretty soon

References tend to be a bit confusing at first to C veterans coming to C++

• Because they are tantalizingly reminiscent of pointers, yet somehow different
  • For example, you can create both a reference and a pointer to refer to rats (A-3)
• Then, you could
• Use the expressions rodents and *prats interchangeably with rats
  • And use the expressions &rodents and prats interchangeably with &rats

Example of (A-3)

int rats = 255;
int & rodents = rats; // rodents a reference
int * prats = &rats;  // prats a pointer

From this standpoint

• A reference looks a lot like a pointer in disguised notation in which the * dereferencing operator is understood implicitly
  • And, in fact, that’s more or less what a reference is
• But there are differences besides those of notation
• For one, it is necessary to initialize the reference when you declare it; you can’t declare the reference and then assign it a value later the way you can with a pointer (A-4):

Example of (A-4)

int rat;
int & rodent;
rodent = rat; // No, you can’t do this

Remember

• You should initialize a reference variable when you declare it

A reference is rather like a const pointer; you have to initialize it when you create it

• And once a reference pledges its allegiance to a particular variable, it sticks to its pledge
  • That is, (A-5)
• (A-5) is, in essence, a disguised notation for something like this (A-6)
  • Here, the reference rodents plays the same role as the expression *pr

Example of (A-5)

int & rodents = rats;

Example of (A-6)

int * const pr = &rats;

(A-7) shows what happens

• If you try to make a reference change allegiance from a rats variable to a bunnies variable

Example of (A-7)

// secondref.cpp -- defining and using a reference
#include <iostream>
int main()
{
	using namespace std;
	int rats = 256;
	int & rodents = rats; // rodents is a reference
 
	cout << "rats = " << rats;
	cout << ", rodents = " << rodents << endl;
 
	cout << "rats address = " << &rats;
	cout << ", rodents address = " << &rodents << endl;
 
	int bunnies = 128;
	rodents = bunnies; // can we change the reference?
	cout << "bunnies = " << bunnies;
	cout << ", rats = " << rats;
	cout << ", rodents = " << rodents << endl;
 
	cout << "bunnies address = " << &bunnies;
	cout << ", rodents address = " << &rodents << endl;
	return 0;
}

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

Initially, rodents refers to rats

• But then the program apparently attempts to make rodents a reference to bunnies (A-8):
• For a moment, it looks as if this attempt has succeeded because the value of rodents changes from 256 to 128
• But closer inspection reveals that rats also has changed to 128 and that rats and rodents still share the same address
• Which differs from the bunnies address
• Because rodents is an alias for rats
• The assignment statement really means the same as the following (A-9)
• That is, it means “Assign the value of the bunnies variable to the rat variable.”
• In short, you can set a reference by an initializing declaration
• Not by assignment

Example of (A-8)

rodents = bunnies;

Example of (A-9)

rats = bunnies;

Suppose you tried the following (A-10)

• Initializing rodents to *pt makes rodents refer to rats
  • Subsequently altering pt to point to bunnies does not alter the fact that rodents refers to rats

Example of (A-10)

int rats = 256;
int * pt = &rats;
int & rodents = *pt;
int bunnies = 128;
pt = &bunnies;