• 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;

• Whereas default arguments
  • Let you call the same function by using varying numbers of arguments
• function polymorphism, also called function overloading
  • Lets you use multiple functions sharing the same name

The word polymorphism

• Means having many forms, so function polymorphism lets a function have many forms

Similarly, the expression function overloading

• Means you can attach more than one function to the same name, thus overloading the name

Both expressions boil down to the same thing,

• But we’ll usually use the expression function overloading —it sounds harder working

You can use function overloading

• To design a family of functions that do essentially the same thing, but using different argument lists

Overloaded functions are analogous to verbs having more than one meaning

• For example, Mr. Computerson can root at the ball park for the home team, and he can root in soil for truffles
  • The context (one hopes) tells you which meaning of root is intended in each case
    • Similarly, C++ uses the context to decide which version of an overloaded function is intended

The key to function overloading

• Is a function’s argument list, also called the function signature

If two functions use the same number and types of arguments in the same order

• They have the same signature; the variable names don’t matter

C++ enables you to define two functions by the same name

• Provided that the functions have different signatures

The signature can differ

• In the number of arguments or in the type of arguments, or both
  • For example, you can define a set of print() functions with the following prototypes (A-1):
    • When you then use a print() function, the compiler matches your use to the prototype that has the same signature (A-2):
      • For example, print(“Computers”, 15) uses a string and an integer as arguments, and it matches Prototype #1

Example of (A-1)

void print(const char * str, int width); // #1
void print(double d, int width);         // #2
void print(long l, int width);           // #3
void print(int i, int width);            // #4
void print(const char *str);             // #5

Example of (A-2)

print("Computers", 15);	// use #1
print("Keyboard");	         // use #5
print(2009.0, 10);	         // use #2
print(2009, 12);		// use #4
print(2009L, 15);		// use #3

When you use overloaded functions, you need to be sure you use the proper argument types in the function call

• For example, consider the following statements (A-3):
  • Which prototype does the print() call match in (A-1)? It doesn’t match any of them!

Example of (A-3)

unsigned int year = 3210;
print(year, 6); // ambiguous call

A lack of a matching prototype doesn’t automatically rule out using one of the functions because C++ will try to use standard type conversions to force a match

• If, say, the only print() prototype were #2
• The function call print(year, 6) would convert the year value to type double
• But in the earlier code (A-1) there are three prototypes that take a number as the first argument, providing three different choices for converting year
  • Faced with this ambiguous situation, C++ rejects the function call as an error

Some signatures that appear to be different from each other nonetheless can’t coexist

• For example, consider these two prototypes (A-4):
  • You might think this is a place you could use function overloading because the function signatures appear to be different
• But consider things from the compiler’s standpoint
  • Suppose you have code like this (A-5):
    • The x argument matches both the double x prototype and the double &x prototype
      • The compiler has no way of knowing which function to use
• Therefore, to avoid such confusion
  • When it checks function signatures, the compiler considers a reference to a type and the type itself to be the same signature

Example of (A-4)

double cube(double x);
double cube(double & x);

Example of (A-5)

cout << cube(x);

The function-matching process does discriminate between const and non-const variables

• Consider the following prototypes (A-6):
  • Here’s what various function calls would match (A-7):
• The dribble() function has two prototypes—one for const pointers and one for regular pointers—and the compiler selects one or the other, depending on whether the actual argument is const
• The dabble() function only matches a call with a non-const argument, but the drivel() function matches calls with either const or non-const arguments
  • The reason for this difference in behavior between drivel() and dabble() is that it’s valid to assign a non-const value to a const variable, but not vice versa

Example of (A-6)

void dribble(char * bits);		// overloaded
void dribble(const char *cbits);	// overloaded
void dabble(char * bits);		// not overloaded
void drivel(const char * bits);	// not overloaded

Example of (A-7)

const char p1[20] = "How's the weather?";
char p2[20] = "How's business?";
dribble(p1);	// dribble(const char *);
dribble(p2);	// dribble(char *);
dabble(p1);	// no match
dabble(p2);	// dabble(char *);
drivel(p1);	// drivel(const char *);
drivel(p2);	// drivel(const char *);

Keep in mind that the signature, not the function type, enables function overloading

• For example, the following two declarations are incompatible (A-8):
• Therefore, C++ doesn’t permit you to overload gronk() in this fashion
• You can have different return types, but only if the signatures are also different (A-9):

Example of (A-8)

long gronk(int n, float m);	   // same signatures,
double gronk(int n, float m); // hence not allowed

Example of (A-9)

long gronk(int n, float m);	     // different signatures,
double gronk(float n, float m); // hence allowed

After we discuss templates later in other page

• We’ll further discuss function matching

• For example, consider a bank certificate of deposit, which is often called a CD
• A CD is a bank account that does not allow withdrawals for a specified number of months
• A CD naturally has three pieces of data associated with it:
• The account balance
•  The interest rate for the account
•  The term, which is the number of months until maturity
• The first two items can be represented
• As values of type double
• The number of months can be represented
• As a value of type int

(A-1) shows the definition of a structure called

• CDAccountV1 that can be used for this kind of account
  • (The V1 stands for version 1. We will define an improved version later in this page.)

Example of (A-1)

// strctfirst.cpp -- program to demonstrate the CDAccountV1 structure type
#include <iostream>
using namespace std;
 
// structure for a bank certificate of deposit:
struct CDAccountV1
{
    double balance;
    double interestRate;
    int term; // months until maturity
};
 
void getData(CDAccountV1& theAccount);
// postcondition: theAccount.balance, theAccount.interestRate, and 
// theAccount.term have been given values that the user entered at the keyboard
 
int main( )
{
    CDAccountV1 account;
    getData(account);
 
    double rateFraction, interest;
    rateFraction = account.interestRate/100.0;
    interest = account.balance*(rateFraction*(account.term/12.0));
    account.balance = account.balance + interest;
 
    cout.setf(ios::fixed);
    cout.setf(ios::showpoint);
    cout.precision(2);
    cout << "When your CD matures in " 
         << account.term << " months,\n"
         << "it will have a balance of $" 
         << account.balance << endl;
 
    return 0;
}
 
// uses iostream:
void getData(CDAccountV1& theAccount)
{
    cout << "Enter account balance: $";
    cin >> theAccount.balance;
    cout << "Enter account interest rate: ";
    cin >> theAccount.interestRate;
    cout << "Enter the number of months until maturity: ";
    cin >> theAccount.term;
}

Here is the output from the program in (A-1):

Structure Types

The structure definition in (A-1)

• Is as follows (A-2):

Example of (A-2)

struct CDAccountV1
{
	double balance;
	double interestRate;
	int term; // months until maturity
};

The keyword struct

• Announces that this is a structure type definition

The identifier CDAccountV1

• Is the name of the structure type, which is known as the structure tag
  • The structure tag can be any legal identifier that is not a keyword
    • Although this is not required by the C++ language, structure tags are usually spelled starting with an uppercase letter

The identifiers declared inside the braces, {}

• Are called member names

As illustrated in (A-2), a structure type definition ends

• With a closing brace and a semicolon

A structure definition

• Is usually placed outside any function definition
  • (In the same way that globally defined constant declarations are placed outside all function definitions.)

The structure type

• Is then a global definition that is available to all the code that follows the structure definition

Once a structure type definition has been given

• The structure type can be used just like the predefined types int, char, and so forth

Note that in (A-1) the structure type CDAccountV1

• Is used to declare a variable in the function main
  • And then it is used as the name of the parameter type for the function getData

A structure variable

• Can hold values just like any other variable can

A structure value

• Is a collection of smaller values called member values

There is one member value for each member name declared in the structure definition

• For example, a value of the type CDAccountV1
  • Is a collection of three member values, two of type double and one of type int

The member values that together make up the structure value

• Are stored in member variables, which we discuss next

Each structure type specifies a list of member names

• In (A-1) the structure CDAccountV1 has three member names:
• balance
• interestRate
• term
• Each of these member names can be used to pick out one smaller variable that is a part of the larger structure variable
• These smaller variables are called member variables

Member variables

• Are specified by giving the name of the structure variable followed by a dot and then the member name
• For example, if account is a structure variable of type CDAccountV1 (as declared in(A-1)), then the structure variable account has the following three member variables:
• account.balance
• account.interestRate
• account.term
• The first two member variables are of type double, and the last is of type int
• As illustrated in (A-1), these member variables can be used just like any other variables of those types
• For example, the following line from the program in (A-1) will add the value contained in the member variable account.balance and the value contained in the ordinary variable interest and will then place the result in the member variable account.balance (A-3):

Example of (A-3)

account.balance = account.balance + interest;

Two or more structure types may use the same member names

• For example, it is perfectly legal to have the following two type definitions in the same program (A-4)
  • This coincidence of names will produce no problems

Example of (A-4)

struct FertilizerStock
{
	double quantity;
	double nitrogenContent;
};
 
struct CropYield
{
	int quantity;
	double size;
};

For example, if you declare the following two structure variables (A-5):

• Then the quantity of Super Grow fertilizer is stored in the member variable superGrow.quantity
  • And the quantity of apples produced is stored in the member variable apples.quantity
    • The dot operator and the structure variable specify which quantity is meant in each instance

Example of (A-5)

FertilizerStock superGrow;
CropYield apples;

A structure value can be viewed as a collection of member values

• A structure value can also be viewed as a single (complex) value (that just happens to be made up of member values)

Since a structure value can be viewed as a single value

• Structure values and structure variables can be used in the same ways that you use simple values and simple variables of the predefined types such as int
  • In particular, you can assign structure values using the equal sign

For example, if apples and oranges are structure variables of the type CropYield defined earlier, then the following is perfectly legal (A-6):

• The previous assignment statement is equivalent to (A-7)

Example of (A-6)

apples = oranges;

Example of (A-7)

apples.quantity = oranges.quantity;
apples.size = oranges.size;

Forgetting a Semicolon in a Structure Definition

When you add the final brace,}, to a structure definition, it feels like the structure definition is finished, but it is not

• You must also place a semicolon after that final brace
  • There is a reason for this, even though the reason is a feature that we will have no occasion to use
• A structure definition is more than a definition
  • It can also be used to declare structure variables
    • You are allowed to list structure variable names between that final brace and that final semicolon
      • For example, the following defines a structure called WeatherData and declares two structure variables, dataPoint1 and dataPoint2, both of type WeatherData (A-8):

Example of (A-8)

struct WeatherData
{
	double temperature;
	double windVelocity;
} dataPoint1, dataPoint2;

Structures as Function Arguments

A function can have

• Call-by-value parameters of a structure type or call-by-reference parameters of a structure type, or both
  • The program in (A-1), for example, includes a function named getData that has a call-by-reference parameter with the structure type CDAccountV1

A structure type can also be the type for the value returned by a function

• For example, the following defines a function that takes one argument of type CDAccountV1 and returns a different structure of type CDAccountV1 (A-9)
  • The structure returned will have the same balance and term as the argument, but will pay double the interest rate that the argument pays

Example of (A-9)

CDAccountV1 doubleInterest(CDAccountV1 oldAccount)
{
	CDAccountV1 temp;
	temp = oldAccount;
	temp.interestRate = 2*oldAccount.interestRate;
	return temp;
}

(A-9) notice the local variable temp of type CDAccountV1; temp is used to build up a complete structure value of the desired kind

• Which is then returned by the function

If myAccount is a variable of type CDAccountV1 that has been given values for its member variables

• Then the following will give yourAccount values for an account with double the interest rate of myAccount (A-10):

Example of (A-10)

CDAccountV1 yourAccount;
yourAccount = doubleInterest(myAccount);

Use Hierarchical Structures

Sometimes it makes sense to have structures whose members are themselves smaller structures

• For example, a structure type called PersonInfo
  • That can be used to store a person’s height, weight, and birth date can be defined as follows (A-11):

Example of (A-11)

struct Date
{
	int month;
	int day;
	int year;
};
 
struct PersonInfo
{
	double height; // in inches
	int weight; // in pounds
	Date birthday;
};

A structure variable of type PersonInfo is declared in the usual way (A-12):


Example of (A-12)

PersonInfo person1;

If the structure variable person1 has had its value set to record a person’s birth date

• Then the year the person was born can be output to the screen as follows (A-13):

Example of (A-13)

cout << person1.birthday.year;

The way to read such expressions is left to right, and very carefully

• Starting at the left end, person1 is a structure variable of type PersonInfo
  • To obtain the member variable with the name birthday, you use the dot operator as follows (A-14):
    • This member variable is itself a structure variable of type Date
      • Thus, this member variable itself has member variables
        • A member variable of the structure variable person1.birthday is obtained by adding a dot and the member variable name, such as year, which produces the expression person1.birthday.year shown above (A-13)

Example of (A-14)

person1.birthday

In (A-15) we have rewritten the class for a certificate of deposit from (A-1)

• This new version has a member variable of the structure type Date that holds the date of maturity
  • We have also replaced the single balance member variable with two new member variables giving the initial balance and the balance at maturity

Example of (A-15)

// strctsec.cpp -- program to demonstrate the CDAccount structure type
#include <iostream>
using namespace std;
 
struct Date
{
    int month;
    int day;
    int year;
};
 
// improved structure for a bank certificate of deposit:
struct CDAccount
{
    double initialBalance;
    double interestRate;
    int term; // months until maturity
    Date maturity; // date when CD matures
    double balanceAtMaturity;
};
 
void getCDData(CDAccount& theAccount);
// postcondition: theAccount.initialBalance, theAccount.interestRate, 
// theAccount.term, and theAccount.maturity 
// have been given values that the user entered at the keyboard
 
void getDate(Date& theDate);
// postcondition: theDate.month, theDate.day, and theDate.year 
// have been given values that the user entered at the keyboard
 
int main( )
{
    CDAccount account;
    cout << "Enter account data on the day account was opened:\n";
    getCDData(account);
 
    double rateFraction, interest;
    rateFraction = account.interestRate/100.0;
    interest = account.initialBalance*(rateFraction*(account.term/12.0));
    account.balanceAtMaturity = account.initialBalance + interest;
 
    cout.setf(ios::fixed);
    cout.setf(ios::showpoint);
    cout.precision(2);
    cout << "When the CD matured on " 
         << account.maturity.month << "-" << account.maturity.day
         << "-" << account.maturity.year << endl
         << "it had a balance of $" 
         << account.balanceAtMaturity << endl;
    return 0;
}
 
// uses iostream:
void getCDData(CDAccount& theAccount)
{
    cout << "Enter account initial balance: $";
    cin >> theAccount.initialBalance;
    cout << "Enter account interest rate: ";
    cin >> theAccount.interestRate;
    cout << "Enter the number of months until maturity: ";
    cin >> theAccount.term;
    cout << "Enter the maturity date:\n";
    getDate(theAccount.maturity);
}
 
// uses iostream:
void getDate(Date& theDate)
{
    cout << "Enter month: ";
    cin >> theDate.month;
    cout << "Enter day: ";
    cin >> theDate.day;
    cout << "Enter year: ";
    cin >> theDate.year;
}

Here is the output from the program in (A-15): 

Initializing Structures

You can initialize a structure at the time that it is declared

• To give a structure variable a value, follow it by an equal sign and a list of the member values enclosed in braces

For example, the following definition of a structure type for a date was given in the previous subsection (A-16):

• Once the type Date is defined, you can declare and initialize a structure variable called dueDate as follows (A-17):
  • The initializing values must be given in the order that corresponds to the order of member variables in the structure type definition
    • In this example (A-17):
      • dueDate.month receives the first initializing value of 12
      • dueDate.day receives the second value of 31
      • dueDate.year receives the third value of 2003

It is an error if there are more initializer values than struct members

• If there are fewer initializer values than struct members, the provided values are used to initialize data members, in order
  • Each data member without an initializer is initialized to a zero value of an appropriate type for the variable

Example of (A-16)

struct Date
{
	int month;
	int day;
	int year;
};

Example of (A-17)

Date dueDate = {12, 31, 2003};

• Whether they are data items or member functions
  • Either in the public or the private section of a class

 


But because one of the main precepts of OOP is to hide the data

• Data items normally go into the private section

 


The member functions that constitute the class interface

• Go into the public section
  • Otherwise, you can’t call those functions from a program

You can also put member functions

• In the private section
  • You can’t call such functions directly from a program, but the public methods can use them
    • Typically, you use private member functions to handle implementation details that don’t form part of the public interface

You don’t have to use the keyword private in class declarations

• Because that is the default access control for class objects (A-1):
  • However, I will explicitly use the private label in order to emphasize the concept of data hiding

 


Example of (A-1)

class World
{
	float mass; // private by default
	char name[20]; // private by default
public:
	void tellall(void);
	...
};

Classes and Structures

Class descriptions look much like structure declarations

• With the addition of member functions
• And the public and private visibility labels
• In fact, C++ extends to structures the same features classes have

The only difference is that

• The default access type for a structure is public
• Whereas the default type for a class is private

C++ programmers commonly use

• Classes to implement class descriptions while restricting structures to representing pure data objects
• Or, occasionally, classes with no private components

• Are a C++ enhancement designed to speed up programs

The primary distinction between normal functions and inline functions

• Is not in how you code them
  • But in how the C++ compiler incorporates them into a program

To understand the distinction between inline functions and normal functions

• You need to peer more deeply into a program’s innards than we have so far
  • Let’s do that now

The final product of the compilation process

• Is an executable program, which consists of a set of machine language instructions
  • When you start a program, the operating system loads these instructions into the computer’s memory so that each instruction has a particular memory address
    • The computer then goes through these instructions step-by-step

Sometimes, as when you have a loop or a branching statement

• Program execution skips over instructions, jumping backward or forward to a particular address

Normal function calls

• Also involve having a program jump to another address (the function’s address)
  • And then jump back when the function terminates

Let’s look at a typical implementation of that process in a little more detail

• When a program reaches the function call instruction
  • The program stores the memory address of the instruction immediately following the function call
    • Copies function arguments to the stack (a block of memory reserved for that purpose)
      • Jumps to the memory location that marks the beginning of the function
        • Executes the function code (perhaps placing a return value in a register)
          • And then jumps back to the instruction whose address it saved

Jumping back and forth and keeping track of where to jump

• Means that there is an overhead in elapsed time to using functions

C++ inline functions

• Provide an alternative

In an inline function

• The compiled code is “in line” with the other code in the program
  • That is, the compiler replaces the function call with the corresponding function code

With inline code

• The program doesn’t have to jump to another location to execute the code and then jump back
  • Inline functions thus run a little faster than regular functions
    • But they come with a memory penalty

If a program calls an inline function at 10 separate locations

• Then the program winds up with 10 copies of the function inserted into the code
  • See (Image-1)

(Image-1)  Inline functions versus regular functions

You should be selective about using inline functions

• If the time needed to execute the function code is long compared to the time needed to handle the function call mechanism
• Then the time saved is a relatively small portion of the entire process
• If the code execution time is short
• Then an inline call can save a large portion of the time used by the non-inline call
• On the other hand, you are now saving a large portion of a relatively quick process, so the absolute time savings may not be that great unless the function is called frequently

To use this feature, you must take at least one of two actions:

• Preface the function declaration with the keyword inline
• Preface the function definition with the keyword inline

A common practice is

• To omit the prototype
  • And to place the entire definition (meaning the function header and all the function code) where the prototype would normally go

The compiler does not have to honor your request to make a function inline

• It might decide the function is too large
  • Or notice that it calls itself (recursion is not allowed or indeed possible for inline functions)
    • Or the feature might not be turned on or implemented for your particular compiler

(A-1) illustrates the inline technique with an inline square() function that squares its argument

• Note that placed the entire definition is on one line
  • That’s not required, but if the definition doesn’t fit on one line, the function is probably a poor candidate for an inline function

Example of (A-1)

// inline.cpp -- using an inline function
#include <iostream>
 
// an inline function definition
inline double square(double x) { return x * x; }
 
int main()
{
	using namespace std;
	double a, b;
	double c = 13.0;
 
	a = square(5.0);
	b = square(4.5 + 7.5); // can pass expressions
	cout << "a = " << a << ", b = " << b << "\n";
	cout << "c = " << c;
	cout << ", c squared = " << square(c++) << "\n";
	cout << "Now c = " << c << "\n";
	return 0;
}

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

This output illustrates that inline functions pass arguments by value just like regular functions do

• If the argument is an expression, such as 4.5 + 7.5, the function passes the value of the expression—12 in this case
  • This makes C++’s inline facility far superior to C’s macro definitions
    • See the “Inline Versus Macros”

Even though the program doesn’t provide a separate prototype, C++’s prototyping features are still in play

• That’s because the entire definition, which comes before the function’s first use, serves as a prototype
  • This means you can use square() with an int argument or a long argument
    • And the program automatically type casts the value to type double before passing it to the function

Inline Versus Macros

The inline facility is an addition to C++

• C uses the preprocessor #define statement to provide macros
  • Which are crude implementations of inline code
    • For example, here’s a macro for squaring a number (A-2):

Example of (A-2)

#define SQUARE(X) X*X

(A-2) this works not by passing arguments but through text substitution

• With the X acting as a symbolic label for the “argument” (A-3):

Example of (A-3)

a = SQUARE(5.0); // is replaced by a = 5.0*5.0;
b = SQUARE(4.5 + 7.5); // is replaced by b = 4.5 + 7.5 * 4.5 + 7.5;
d = SQUARE(c++); // is replaced by d = c++*c++;

(A-3) only the first example here works properly

• You can improve matters with a liberal application of parentheses (A-4):

Example of (A-4)

#define SQUARE(X) ((X)*(X))

Still, the problem remains that macros don’t pass by value

• Even with this new definition, SQUARE(c++) increments c twice
  • But the inline square() function in (A-1) evaluates c, passes that value to be squared, and then increments c once

The intent here is not to show you how to write C macros

• Rather, it is to suggest that if you have been using C macros to perform function-like services
  • You should consider converting them to C++ inline functions

• 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):

• Cheap
• Moderate
• Expensive
• Extravagant
• Excessive

You can extend an if else if else sequence to handle five alternatives

• But the C++ switch statement more easily handles selecting a choice from an extended list
  • Here’s the general form for a switch statement (A-1):

Example of (A-1)

switch (integer-expression)
{
      case label1 : statement(s)
      case label2 : statement(s)
      ...
      default : statement(s)
}

A C++ switch statement acts as a routing device

• That tells the computer which line of code to execute next

On reaching a switch statement

• A program jumps to the line labeled with the value corresponding to the value of integer-expression
  • For example, if integer-expression has the value 4, the program goes to the line that has a case 4: label

The value integer-expression

• As the name suggests, must be an expression that reduces to an integer value

Also, each label

• Must be an integer constant expression

Most often, labels

• Are simple int or char constants, such as 1 or ‘q’, or enumerators

If integer-expression doesn’t match any of the labels

• The program jumps to the line labeled default
  • The default label is optional
    • If you omit it and there is no match, the program jumps to the next statement following the switch
      • See (Image-1)

(Image-1) The structure of switch statements

The switch statement

• Is different from similar statements in languages such as Pascal in a very important way

Each C++ case label functions

• Only as a line label, not as a boundary between choices
  • That is, after a program jumps to a particular line in a switch
    • It then sequentially executes all the statements following that line in the switch unless you explicitly direct it otherwise

Execution does not automatically stop at the next case

• To make execution stop at the end of a particular group of statements
  • You must use the break statement
    • This causes execution to jump to the statement following the switch

(A-2) shows how to use switch and break together to implement a simple menu for executives

• The program uses a showmenu() function to display a set of choices
  • A switch statement then selects an action based on the user’s response

Compatibility Note

• Some C++ implementations treat the \a escape sequence (used in case 1 in (A-2)) as silent

Example of (A-2)

// switch.cpp -- using the switch statement
#include <iostream>
using namespace std;
void showmenu(); // function prototypes
void report();
void comfort();
int main()
{
	showmenu();
	int choice;
	cin >> choice;
 
	while (choice != 5)
	{
		switch(choice)
		{
		case 1 : cout << "\a\n";
			break;
		case 2 : report();
			break;
		case 3 : cout << "The boss was in all day.\n";
			break;
		case 4 : comfort();
			break;
		default : cout << "That's not a choice.\n";
		}
		showmenu();
		cin >> choice;
	}
	cout << "Bye!\n";
	return 0;
}
 
void showmenu()
{
	cout << "Please enter 1, 2, 3, 4, or 5:\n"
		"1) alarm 2) report\n"
		"3) alibi 4) comfort\n"
		"5) quit\n";
}
void report()
{
	cout << "It's been an excellent week for business.\n"
		"Sales are up 150%. Expenses are down 35%.\n";
}
void comfort()
{
	cout << "Your employees think you are the finest CEO\n"
		"in the industry. The board of directors think\n"
		"you are the finest CEO in the industry.\n";
}

Here is a sample run of the executive menu program in (A-2):

The while loop terminates

• When the user enters 5

Entering 1 through 4

• Activates the corresponding choice from the switch list

Entering 10

• Triggers the default statements

As noted earlier, this program needs the break statements

• To confine execution to a particular portion of a switch statement
  • To see that this is so, you can remove the break statements from (A-2) and see how it works afterward
    • You’ll find, for example, that entering 2 causes the program to execute all the statements associated with case labels 2, 3, 4, and the default
      • C++ works this way because that sort of behavior can be useful

For one thing, it makes it simple to use multiple labels

• For example, suppose you rewrote (A-2) using characters instead of integers as menu choices and switch labels
  • In that case, you could use both an uppercase and a lowercase label for the same statements (A-3):

Example of (A-3)

// switch.cpp -- using the switch statement
#include <iostream>
using namespace std;
void showmenu(); // function prototypes
void report();
void comfort();
int main()
{
	showmenu();
	char choice;
	cin >> choice;
	while (choice != 'Q' && choice != 'q')
	{
		switch(choice)
		{
		case 'a':
		case 'A': cout << "\a\n";
			break;
		case 'r':
		case 'R': report();
			break;
		case 'l':
		case 'L': cout << "The boss was in all day.\n";
			break;
		case 'c':
		case 'C': comfort();
			break;
		default : cout << "That's not a choice.\n";
		}
		showmenu();
		cin >> choice;
	}
	cout << "Bye!\n";
	return 0;
}
 
void showmenu()
{
	cout << "Please enter a, r, l, c, or q:\n"
		"a) alarm r) report\n"
		"l) alibi c) comfort\n"
		"q) quit\n";
}
void report()
{
	cout << "It's been an excellent week for business.\n"
		"Sales are up 150%. Expenses are down 35%.\n";
}
void comfort()
{
	cout << "Your employees think you are the finest CEO\n"
		"in the industry. The board of directors think\n"
		"you are the finest CEO in the industry.\n";
}

(A-3) because there is no break immediately following case ‘a’, program execution passes on to the next line

• Which is the statement following case ‘A’