lafore_robert_objectoriented_programming_in_c

In main() there are two pairs of numbers—the first pair is not ordered and the second pair is ordered. The order() function is called once for each pair, and then all the numbers are printed out. The output reveals that the first pair has been swapped while the second pair hasn’t. Here it is:

n1=11

n2=99

n3=22

n4=88

In the order() function the first variable is called numb1 and the second is numb2. If numb1 is greater than numb2 the function stores numb1 in temp, puts numb2 in numb1, and finally puts temp back in numb2. Remember that numb1 and numb2 are simply different names for whatever arguments were passed; in this case, n1 and n2 on the first call to the function, and n2 and n3 on the second call. The effect is to check the ordering of the original arguments in the calling program and swap them if necessary.

Using reference arguments in this way is a sort of remote-control operation. The calling program tells the function what variables in the calling program to operate on, and the function modifies these variables without ever knowing their real names. It’s as if you called the house painters and, although they never left their office, you sat back and watched as your dining room walls mysteriously changed color.

Passing Structures by Reference

You can pass structures by reference just as you can simple data types. Here’s a program, REFERST, that performs scale conversions on values of type Distance. A scale conversion involves multiplying a group of distances by a factor. If a distance is 6'–8'', and a scale factor is 0.5, the new distance is 3'–4''. Such a conversion might be applied to all the dimensions of a building to make the building shrink but remain in proportion.

//referst.cpp

//demonstrates passing structure by reference #include <iostream>

Chapter 5

188

REFERST initializes two Distance variables—d1 and d2—to specific values, and displays them. Then it calls the scale() function to multiply d1 by 0.5 and d2 by 0.25. Finally, it displays the resulting values of the distances. Here’s the program’s output:

d1 = 12’-6.5”

d2 = 10’-5.5”

d1 = 6’-3.25”

d2 = 2’-7.375”

Here are the two calls to the function scale():

scale(d1, 0.5); scale(d2, 0.25);

The first call causes d1 to be multiplied by 0.5 and the second causes d2 to be multiplied by 0.25. Notice that these changes take place directly to d1 and d2. The function doesn’t return anything; the operation is performed directly on the Distance argument, which is passed by reference to scale(). (Since only one value is changed in the calling program, you could rewrite the function to pass the argument by value and return the scaled value. Calling such a function would look like this:

d1 = scale(d1, 0.5);

However, this is unnecessarily verbose.)

Notes on Passing by Reference

References don’t exist in C, where pointers serve a somewhat similar purpose, although often less conveniently. Reference arguments were introduced into C++ to provide flexibility in a variety of situations involving objects as well as simple variables.

The third way to pass arguments to functions, besides by value and by reference, is to use pointers. We’ll explore this in Chapter 10.

Overloaded Functions

An overloaded function appears to perform different activities depending on the kind of data sent to it. Overloading is like the joke about the famous scientist who insisted that the thermos bottle was the greatest invention of all time. Why? “It’s a miracle device,” he said. “It keeps hot things hot, but cold things it keeps cold. How does it know?”

It may seem equally mysterious how an overloaded function knows what to do. It performs one operation on one kind of data but another operation on a different kind. Let’s clarify matters with some examples.

cout << endl;

}

//--------------------------------------------------------------

//repchar()

//displays specified number of copies of specified character void repchar(char ch, int n)

{

This program prints out three lines of characters. Here’s the output:

*********************************************

=============================================

++++++++++++++++++++++++++++++

The first two lines are 45 characters long, and the third is 30.

The program contains three functions with the same name. There are three declarations, three function calls, and three function definitions. What keeps the compiler from becoming hopelessly confused? It uses the function signature—the number of arguments, and their data types—to distinguish one function from another. In other words, the declaration

void repchar();

which takes no arguments, describes an entirely different function than the declaration

void repchar(char);

which takes one argument of type char, or the declaration

void repchar(char, int);

which takes one argument of type char and another of type int.

The compiler, seeing several functions with the same name but different numbers of arguments, could decide the programmer had made a mistake (which is what it would do in C). Instead, it very tolerantly sets up a separate function for every such definition. Which one of these functions will be called depends on the number of arguments supplied in the call. Figure 5.8 shows this process.

Chapter 5

194

//-------------------------------------------------------------

//factfunc()

//calls itself to calculate factorials unsigned long factfunc(unsigned long n)

{

if(n > 1)

return n * factfunc(n-1); //self call else

return 1;

}

The output of this program is the same as the FACTOR program in Chapter 3.

The main() part of FACTOR2 looks reasonable: it calls a function, factfunc(), with an argument that is a number entered by the user. This function then returns the factorial of that number to main().

The function factfunc() is another story. What’s it doing? If n is greater than 1, the function calls itself. Notice that when it does this it uses an argument one less than the argument it was called with. Suppose it was called from main() with an argument of 5. It will call a second version of itself with an argument of 4. Then this function will call a third version with an argument of 3, and so on.

Notice that each version of the function stores its own value of n while it’s busy calling another version of itself.

After factfunc() calls itself four times, the fifth version of the function is called with an argument of 1. It discovers this with the if statement, and instead of calling itself, as previous versions have, it returns 1 to the fourth version. The fourth version has stored a value of 2, so it multiplies the stored 2 by the returned 1, and returns 2 to the third version. The third version has stored 3, so it multiplies 3 by the returned 2, and returns 6 to the second version. The second version has stored 4, so it multiplies this by the returned 6 and returns 24 to the first version. The first version has stored 5, so it multiplies this by the returned 24 and returns 120 to main().

Thus in this example we have five function calls followed by five function returns. Here’s a summary of this process: