Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Chapter 5
Introducing Structure into Your Programs

WHAT YOU WILL LEARN IN THIS CHAPTER:

How to declare and write your own C++ functions
How function arguments are defined and used
How to pass arrays to and from a function
What pass-by-value means
How to pass pointers to functions
How to use references as function arguments, and what pass-by-reference means
How the const modifier affects function arguments
How to return values from a function
How to use recursion

WROX.COM CODE DOWNLOADS FOR THIS CHAPTER

You can find the wrox.com code downloads for this chapter on the Download Code tab at www.wrox.com/go/beginningvisualc. The code is in the Chapter 5 download and individually named according to the names throughout the chapter.

UNDERSTANDING FUNCTIONS

Up to now, you haven’t really been able to structure your program code in a modular fashion, because you only know how to construct a program as a single function, main(); but you have been using library functions of various kinds as well as functions belonging to objects. Whenever you write a C++ program, you should have a modular structure in mind from the outset, and as you’ll see, a good understanding of how to implement functions is essential to object-oriented programming.

There’s quite a lot to structuring your C++ programs, so to avoid indigestion, you won’t try to swallow the whole thing in one gulp. After you have chewed over and gotten the full flavor of these morsels, you move on to the next chapter, where you get further into the meat of the topic.

First, I’ll explain the broad principles of how a function works. A function is a self-contained block of code with a specific purpose. A function has a name that both identifies it and is used to call it for execution in a program. The name of a function is global if it is not defined within a namespace, otherwise the name is qualified by the namespace name. The name of a function is not necessarily unique, as you’ll see in the next chapter; however, functions that perform different actions should generally have different names.

The name of a function is governed by the same rules as those for a variable. A function name is, therefore, a sequence of letters and digits, the first of which is a letter, where an underscore (_) counts as a letter. The name of a function should generally reflect what it does, so, for example, you might call a function that counts beans count_beans().

You pass information to a function by means of arguments specified when you invoke it. These arguments must correspond with parameters that appear in the definition of the function. The arguments that you specify replace the parameters used in the definition of the function when the function executes. The code in the function then executes as though it were written using your argument values. Figure 5-1 illustrates the relationship between arguments in the function call and the parameters you specify in the definition of the function.

In Figure 5-1, the add_ints() function returns the sum of the two arguments passed to it. In general, a function returns either a single value to the point in the program where it was called, or nothing at all, depending on how you define the function. You might think that returning a single value from a function is a constraint, but the single value returned can be a pointer that could contain the address of an array, for example. You will learn more about how data is returned from a function a little later in this chapter.

Why Do You Need Functions?

One major advantage that a function offers is that it can be executed as many times as necessary from different points in a program. Without the ability to package a block of code into a function, programs would end up being much larger, because you would typically need to replicate the same code at various points in them. You also use functions to break up a program into easily manageable chunks for development and testing; a program of significant size and complexity that consists of several small blocks of code is much easier to understand and test than if it were written as one large chunk.

Imagine a really big program — let’s say a million lines of code. A program of this size would be virtually impossible to write and debug without functions. Functions enable you to segment the program so that you can write the code piecemeal. You can test each piece independently before bringing it together with the other pieces. This approach also allows the development work to be divided among members of a programming team, with each team member taking responsibility for a tightly specified piece of the program that has a well-defined, functional interface to the rest of the code.

Structure of a Function

As you have seen when writing the function main(), a function consists of a function header that identifies the function, followed by the body of the function between braces that makes up the executable code for the function. Let’s look at an example. You could write a function to raise a value to a given power; that is, to compute the result of multiplying the value x by itself n times, which is xⁿ:

// Function to calculate x to the power n, with n greater than or
// equal to 0
double power(double x, int n)          // Function header
{                                      // Function body starts here...
  double result {1.0};                 // Result stored here
  for(int i {1}; i <= n; i++)
    result *= x;
        
  return result;
}                                      // ...and ends here

The Function Header

Let’s first examine the function header in this example. The following is the first line of the function:

double power(double x, int n)          // Function header

It consists of three parts:

The type of the return value (double, in this case)
The name of the function (power, in this case)
The parameters of the function enclosed between parentheses (x and n, in this case, of types double and int, respectively)

The return value is returned to the calling function when the function is executed, so when the function is called, it results in a value of type double in the expression in which it appears.

Our function has two parameters: x, the value to be raised to a given power, which is of type double, and the value of the power, n, which is of type int. The computation that the function performs is written using these parameter variables together with another variable, result, declared in the body of the function. The parameter names and any variables defined in the body of the function are local to the function.

The General Form of a Function Header

The general form of a function header can be written as follows:

return_type function_name(parameter_list)

The return_type can be any legal type. If the function does not return a value, the return type is specified by the keyword void. The keyword void is also used to indicate the absence of parameters, so a function that has no parameters and doesn’t return a value would have the following function header.

void my_function(void)

An empty parameter list also indicates that a function takes no arguments, so you could omit the keyword void between the parentheses like:

void my_function()

The Function Body

The desired computation in a function is performed by the statements in the function body that follow the function header. The first of these in our power() example declares a variable result that is initialized with the value 1.0. The variable result is local to the function, as are all automatic variables that you declare within the function body. This means that the variable result ceases to exist after the function has completed execution. What might immediately strike you is that if result ceases to exist on completing execution of the function, how is it returned? The answer is that a copy of the value to be returned is made automatically, and this copy is made available to the return point in the program.

The calculation in power() is performed in the for loop. A loop control variable i is declared in the for loop, which assumes successive values from 1 to n. The variable result is multiplied by x once for each loop iteration, so this occurs n times to generate the required value. If n is 0, the statement in the loop won’t be executed at all because the loop continuation condition immediately fails, and so result is left as 1.0.

As I’ve said, the parameters and all the variables declared within the body of a function are local to the function. There is nothing to prevent you from using the same names for variables in other functions for quite different purposes. Indeed, it’s just as well this is so because it would be extremely difficult to ensure variables’ names were always unique within a program containing a large number of functions, particularly if the functions were not all written by the same person.

The scope of variables declared within a function is determined in the same way that I have already discussed. A variable is created at the point at which it is defined and ceases to exist at the end of the block containing it. There is one type of variable that is an exception to this — variables declared as static. I’ll discuss static variables a little later in this chapter.

The return Statement

The return statement returns the value of result to the point where the function was called. The general form of the return statement is

return expression;

where expression must evaluate to a value of the type specified in the function header for the return value. The expression can be any expression you want, as long as you end up with a value of the required type. It can include function calls — even a call of the same function in which it appears, as you’ll see later in this chapter.

If the type of return value has been specified as void, there must be no expression appearing in the return statement. It must be written simply as:

return;

You can also omit the return statement when it is the last statement in the function body and there is no return value.

Alternative Function Syntax

There is an alternative syntax for writing the function header. Here’s an example of the power() function that you saw earlier defined using it:

auto power(double x, int n)-> double   // Function header
{                                      // Function body starts here...
  double result {1.0};                 // Result stored here
  for(int i {1}; i <= n; i++)
    result *= x;
        
  return result;
}                                      // ...and ends here

This will work in exactly the same way as the previous version of the function. The return type of the function appears following the -> in the header. This is referred to as a trailing return type. The auto keyword at the beginning indicates to the compiler that the return type is determined later.

So why was it necessary to introduce the alternative syntax? Isn’t the old syntax good enough? The answer is no. In the next chapter you’ll learn about function templates, where situations can arise when you need to allow for the return type from a function to vary depending on the result of executing the body of the function. You can’t specify that with the old syntax. The alternative function syntax does allow you to do that, as you’ll see in Chapter 6.

Using a Function

At the point at which you use a function in a program, the compiler must know something about it to compile the function call. It needs enough information to be able to identify the function, and to verify that you are using it correctly. If the definition of the function that you intend to use does not appear earlier in the same source file, you must declare the function using a statement called a function prototype.

Function Prototypes

The prototype of a function provides the basic information that the compiler needs to check that you are using the function correctly. It specifies the parameters to be passed to the function, the function name, and the type of the return value — basically, it contains the same information as appears in the function header, with the addition of a semicolon. Clearly, the number of parameters and their types must be the same in the function prototype as they are in the function header in the definition of the function.

A prototype or a definition for each function that you call from within another function must appear before the statements doing the calling. Prototypes are usually placed at the beginning of the program source file. The header files that you’ve been including for standard library functions contain the prototypes of the functions provided by the library, amongst other things.

For the power() function example, you could write the prototype as:

double power(double value, int index);

Note that I have specified names for the parameters in the function prototype that are different from those I used in the function header when I defined the function. This is just to indicate that it’s possible. Most often, the same names are used in the prototype and in the function header in the definition of the function, but this doesn’t have to be so. You can use longer, more expressive parameter names in the function prototype to aid understanding of the significance of the parameters, and then use shorter parameter names in the function definition where the longer names would make the code in the body of the function less readable.

If you like, you can even omit the names altogether in the prototype, and just write:

double power(double, int);

This provides enough information for the compiler to do its job; however, it’s better practice to use some meaningful name in a prototype because it aids readability and, in some cases, makes all the difference between clear code and confusing code. If you have a function with two parameters of the same type (suppose our index was also of type double in the function power(), for example), the use of suitable names indicates clearly which parameter appears first and which second. Without parameter names it would be impossible to tell.

TRY IT OUT: Using a Function

You can see how all this goes together in an example that exercises the power() function:

// Ex5_01.cpp
// Declaring, defining, and using a function
#include <iostream>
using std::cout;
using std::endl;
        
double power(double x, int n);    // Function prototype
        
int main()
{
  int index {3};                  // Raise to this power
  double x {1};                   // Different x from that in function power
  double y {};
        
  y = power(5.0, 3);              // Passing constants as arguments
  cout << endl << "5.0 cubed = " << y;
        
  cout << endl << "3.0 cubed = "
       << power(3.0, index);      // Outputting return value
        
  x = power(x, power(2.0, 2.0));  // Using a function as an argument
  cout << endl                    // with auto conversion of 2nd parameter
       << "x = " << x;
        
  cout << endl;
  return 0;
}
        
// Function to compute positive integral powers of a double value
// First argument is value, second argument is power index
double power(double x, int n)
{                                 // Function body starts here...
  double result {1.0};            // Result stored here
  for(int i {1}; i <= n; i++)
    result *= x;
  return result;
}                                 // ...and ends here

This program shows some of the ways in which you can use the function power(), specifying the arguments to the function in a variety of ways. If you run this example, you get the following output:

5.0 cubed = 125
3.0 cubed = 27
x = 81

How It Works

After the usual #include statement for input/output and the using declarations, you have the prototype for the function power(). If you were to delete this and try recompiling the program, the compiler wouldn’t be able to process the calls to the function in main() and would instead generate a whole series of error messages:

 error C3861: 'power': identifier not found

In a change from previous examples, I’ve used the keyword void in the function main() where the parameter list would usually appear to indicate that no parameters are to be supplied. Previously, I left the parentheses enclosing the parameter list empty, which is also interpreted in C++ as indicating that there are no parameters. Using void in this way is a remnant from the practice in C but you won’t see it very often in C++. As you saw, the keyword void is used as the return type for a function to indicate that no value is returned. If you specify the return type of a function as void, you must not place a value in any return statement within the function; otherwise, you get an error message from the compiler.

You gathered from some of the previous examples that using a function is very simple. To use the function power() to calculate 5.0³ and store the result in a variable y in our example, you have the following statement:

   y = power(5.0, 3);

The values 5.0 and 3 here are the arguments to the function. They happen to be constants, but you can use any expression as an argument, as long as a value of the correct type is ultimately produced. The arguments to the power() function substitute for the parameters x and n, which were used in the definition of the function. The computation is performed using these values, and then, a copy of the result, 125, is returned to the calling function, main(), which is then stored in y. You can think of the function as having this value in the statement or expression in which it appears. You then output the value of y:

   cout << endl << "5.0 cubed = " << y;

The next call of the function is used within the output statement:

   cout << endl << "3.0 cubed = "
        << power(3.0, index);        // Outputting return value

Here, the value returned by the function is transferred directly to the output stream. Because you haven’t stored the returned value anywhere, it is otherwise unavailable to you. The first argument in the call of the function here is a constant; the second argument is a variable.

The function power() is used next in this statement:

   x = power(x, power(2.0, 2.0));    // Using a function as an argument

Here, the power() function is called twice. The first call to the function is the rightmost in the expression, and the result supplies the value for the second argument to the leftmost call. Although the arguments in the sub-expression power(2.0, 2.0) are both specified as the double literal 2.0, the function is actually called with the first argument as 2.0 and the second argument as the integer literal, 2. The compiler converts the double value specified for the second argument to type int, because it knows from the function prototype (shown again here) that the type of the second parameter has been specified as int.

double power(double x, int n);       // Function prototype

The double result 4.0 is returned by the first call to the power() function, and after conversion to type int, the value 4 is passed as the second argument in the next call of the function, with x as the first argument. Because x has the value 3.0, the value of 3.0⁴ is computed and the result, 81.0, stored in x. This sequence of events is illustrated in Figure 5-2.

FIGURE 5-2

This statement involves two implicit conversions from type double to type int that were inserted by the compiler. There’s a possible loss of data when converting from type double to type int, so the compiler issues warning messages when this occurs, even though the compiler itself has inserted the conversations. Generally, relying on automatic conversions where there is potential for data loss is a dangerous programming practice, and it is not at all obvious from the code that this conversion is intended. It is far better to be explicit in your code by using the static_cast operator when necessary. The statement in the example is much better written as:

x = power(x, static_cast<int>(power(2.0, 2)));

Coding the statement like this avoids both the compiler warning messages that the original version caused. Using a static cast does not remove the possibility of losing data in the conversion of data from one type to another. Because you specified it, though, it is clear that this is what you intended, recognizing that data loss might occur.

You could write the loop in the power() function like this:

   for(auto i = 1; i <= n; i++)
      result *= x;

The compiler will deduce the appropriate type for i from the initial value. I prefer to explicitly specify the type as int in this instance because I think it makes the code more readily understood.

PASSING ARGUMENTS TO A FUNCTION

It’s very important to understand how arguments are passed to a function, because it affects how you write functions and how they ultimately operate. There are also a number of pitfalls to be avoided, so we’ll look at the mechanism for this quite closely.

The arguments you specify when a function is called should usually correspond in type and sequence to the parameters that appear in the definition of the function. As you saw in the last example, if the type of an argument you specify in a function call doesn’t correspond with the type of the parameter in the function definition, the compiler arranges for the argument to be converted to the required type, obeying the same rules as those for converting operands that I discussed in Chapter 2. If the conversion is not possible, you get an error message from the compiler. However, even if the conversion is possible and the code compiles, it could result in the loss of data (for example, a conversion from type long to type short) and should therefore be avoided.

There are two mechanisms used to pass arguments to functions. The first mechanism applies when you specify the parameters in the function definition as ordinary variables (not references). This is called the pass-by-value method of transferring data to a function, so let’s look into that first.

The Pass-by-Value Mechanism

With this mechanism, the variables, constants, or expression values that you specify as arguments are not passed to a function at all. Instead, copies of the argument values are created, and these copies are used as the values to be transferred to the function. Figure 5-3 shows this using the example of our power() function.

In Figure 5-3, the value returned by power() is used to initialize result. Each time you call the power() function, the compiler arranges for copies of the arguments to be stored in temporary location plural in memory. During execution of the function, all references to the function parameters are mapped to these temporary copies of the arguments.

TRY IT OUT: Passing-by-Value

One consequence of the pass-by-value mechanism is that a function can’t directly modify the arguments passed to it. You can demonstrate this by deliberately trying to do so in an example:

// Ex5_02.cpp
// A futile attempt to modify caller arguments
#include <iostream>
using std::cout;
using std::endl;
        
int incr10(int num);           // Function prototype
        
int main()
{
  int num {3};
        
  cout << endl << "incr10(num) = " << incr10(num) << endl
       << "num = " << num << endl;
  return 0;
}
        
// Function to increment a variable by 10
int incr10(int num)            // Using the same name might help...
{
  num += 10;                  // Increment the caller argument – hopefully
  return num;                 // Return the incremented value
}

Of course, this program is doomed to failure. If you run it, you get this output:

incr10(num) = 13
num = 3

How It Works

The output confirms that the original value of num remains untouched. The copy of num that was generated and passed as the argument to the incr10() function was incremented and was eventually discarded on exiting from the function.

Clearly, the pass-by-value mechanism provides you with a high degree of protection from having your caller arguments mauled by a rogue function, but it is conceivable that you might actually want to modify caller arguments. Of course, there is a way to do this. Didn’t you just know that pointers would turn out to be incredibly useful?

Pointers as Arguments to a Function

When you use a pointer as an argument, the pass-by-value mechanism still operates as before; however, a pointer is an address of another variable, and if you take a copy of this address, the copy still points to the same variable. This is how specifying a pointer as a parameter enables your function to get at a caller argument.

TRY IT OUT: Pass-by-Pointer

You can change the last example to use a pointer to demonstrate the effect:

// Ex5_03.cpp
// A successful attempt to modify caller arguments
#include <iostream>
using std::cout;
using std::endl;
        
int incr10(int* num);                // Function prototype
        
int main()
{
  int num {3};
 
  int* pnum {&num};                  // Pointer to num

  cout << endl << "Address passed = " << pnum;

  int result {incr10(pnum)};
  cout << endl << "incr10(pnum) = " << result;

  cout << endl << "num = " << num << endl;
  return 0;
}
 
// Function to increment a variable by 10
int incr10(int* num)                 // Function with pointer argument
{
  cout << endl << "Address received = " << num;

  *num += 10;                        // Increment the caller argument
                                     //  - confidently
  return *num;                       // Return the incremented value
}

The output from this example is:

Address passed = 0012FF6C
Address received = 0012FF6C
incr10(pnum) = 13
num = 13

The address values produced by your computer may be different from those shown here, but the two values should be identical.

How It Works

In this example, the principal alterations from the previous version relate to passing a pointer, pnum, in place of the original variable, num. The prototype for the function now has the parameter type specified as a pointer to int, and the main() function has the pointer pnum declared and initialized with the address of num. The function main(), and the function incr10(), output the address sent and the address received, respectively, to verify that the same address is indeed being used in both places. Because the incr10() function is writing to cout, you now call it before the output statement and store the return value in result:

   int result {incr10(pnum)};
   cout << endl << "incr10(pnum) = " << result;

This ensures proper sequencing of the output. The output shows that this time, the variable num has been incremented and has a value that’s now identical to that returned by the function.

In the rewritten version of incr10(), both the statement incrementing the value passed to the function and the return statement now de-reference the pointer to use the value stored.

Passing Arrays to a Function

You can pass an array to a function, but in this case, the array is not copied, even though a pass-by-value method of passing arguments still applies. The array name is converted to a pointer, and a copy of the pointer to the beginning of the array is passed by value to the function. This is quite advantageous because copying large arrays is very time-consuming. As you may have worked out, elements of the array may be changed within a function, and thus, an array is the only type that cannot be passed by value.

TRY IT OUT: Passing Arrays

You can illustrate the ins and outs of this by writing a function to compute the average of a number of values passed to a function in an array:

// Ex5_04.cpp
// Passing an array to a function
#include <iostream>
using std::cout;
using std::endl;
        
double average(double array[], int count);      //Function prototype
        
int main()
{
  double values[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
        
  cout << endl << "Average = "
       << average(values, _countof(values)) << endl;
  return 0;
}
        
// Function to compute an average
double average(double array[], int count)
{
  double sum {};                    // Accumulate total in here
  for(int i {}; i < count; i++)
     sum += array[i];                 // Sum array elements
        
  return sum/count;                   // Return average
}

The program produces the following output:

Average = 5.5

How It Works

The average() function is designed to work with an array of any length. As you can see from the prototype, it accepts two arguments: the array and a count of the number of elements. The function is called in main() in this statement:

   cout << endl << "Average = "
        << average(values, _countof(values)) << endl;

The function is called with the first argument as the array name, values, and the second argument as an expression that evaluates to the number of elements in the array.

The number of elements is produced by the _countof() macro. Note that you cannot apply this macro to an array parameter in a function because only the address of the array is known.

Within the body of the function, the computation is expressed in the way you would expect. There’s no significant difference between this and the way you would write the computation if you implemented it directly in main().

The output confirms that everything works as we anticipated.

TRY IT OUT: Using Pointer Notation When Passing Arrays

You haven’t exhausted all the possibilities here. As you determined at the outset, the array name is passed as a pointer — to be precise, as a copy of a pointer — so within the function, you are not obliged to work with the data as an array at all. You could modify the function in the example to work with pointer notation throughout, in spite of the fact that you are using an array.

// Ex5_05.cpp
// Handling an array in a function as a pointer
#include <iostream>
using std::cout;
using std::endl;
        
double average(double* array, int count);      //Function prototype
        
int main()
{
  double values[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 };
        
  cout << endl << "Average = "
        << average(values, _countof(values)) << endl;
  return 0;
}
        
// Function to compute an average
double average(double* array, int count)
{
  double sum {};                       // Accumulate total in here
  for(int i {}; i < count; i++)
     sum += *array++;                  // Sum array elements
        
  return sum/count;                    // Return average
}

The output is exactly the same as in the previous example.

How It Works

As you can see, the program needed very few changes to make it work with the array as a pointer. The prototype and the function header have been changed, although neither change is absolutely necessary. If you change both back to the original version, with the first parameter specified as a double array, and leave the function body written in terms of a pointer, it works just as well. The most interesting aspect of this version is the body of the for loop statement:

      sum += *array++;                 // Sum array elements

Here, you apparently break the rule about not being able to modify an address specified as an array name because you are incrementing the address stored in array. In fact, you aren’t breaking the rule at all. Remember that the pass-by-value mechanism makes a copy of the original array address and passes that to the function, so you are just modifying the copy here — the original array address is quite unaffected. As a result, whenever you pass a one-dimensional array to a function, you are free to treat the value passed as a pointer in every sense, and change the address in any way that you want.

Passing Multidimensional Arrays to a Function

Passing a multidimensional array to a function is quite straightforward. The following statement declares a two-dimensional array, beans:

double beans[2][4];

You could then write the prototype of a hypothetical function, yield(), like this:

double yield(double beans[2][4]);

When you are defining a multidimensional array as a parameter, you can also omit the first dimension value. Of course, the function needs some way of knowing the extent of the first dimension. For example, you could write this:

double yield(double beans[][4], int index);

Here, the second parameter provides the necessary information about the first dimension. The function can operate with a two-dimensional array, with the value for the first dimension specified by the second argument and with the second dimension fixed at 4.

TRY IT OUT: Passing Multidimensional Arrays

You define such a function in the following example:

// Ex5_06.cpp
// Passing a two-dimensional array to a function
#include <iostream>
using std::cout;
using std::endl;
        
double yield(double array[][4], int n);
        
int main()
{
  double beans[3][4]   {    { 1.0,  2.0,  3.0,  4.0 },
                            { 5.0,  6.0,  7.0,  8.0 },
                            { 9.0, 10.0, 11.0, 12.0 }   };
        
  cout << endl << "Yield = " << yield(beans, _countof(beans))
       << endl;
  return 0;
}
        
// Function to compute total yield
double yield(double beans[][4], int count)
{
  double sum {};
  for(int i {}; i < count; i++)      // Loop through number of rows
     for(int j {}; j < 4; j++)       // Loop through elements in a row
        sum += beans[i][j];
  return sum;
}

The output from this example is:

Yield = 78

How It Works

I have used different names for the parameters in the function header from those in the prototype, just to remind you that this is possible — but in this case, it doesn’t really improve the program at all. The first parameter is defined as an array of an arbitrary number of rows, each row having four elements. You call the function using the array beans with three rows. The second argument is specified by dividing the total size of the array in bytes by the size of the first row. This evaluates to the number of rows in the array.

The computation in the function is a nested for loop with the inner loop summing elements of a single row and the outer loop repeating this for each row.

Using a pointer in a function rather than a multidimensional array as an argument doesn’t really apply particularly well in this example. When the array is passed, it passes an address value that points to an array of four elements (a row). This doesn’t lend itself to an easy pointer operation within the function. You would need to modify the statement in the nested for loop to the following:

sum += *(*(beans + i) + j);

So the computation is probably clearer in array notation.

References as Arguments to a Function

We now come to the second of the two mechanisms for passing arguments to a function. Specifying a parameter to a function as a reference changes the method of passing data for that parameter. The method used is not pass-by-value, where an argument is copied before being transferred to the function, but pass-by-reference, where the parameter acts as an alias for the argument passed. This eliminates any copying of the argument supplied and allows the function to access the caller argument directly. It also means that the de-referencing, which is required when passing and using a pointer to a value, is also unnecessary.

Using reference parameters to a function has particular significance when you are working with objects of a class type. Objects can be large and complex, in which case, the copying process can be very time-consuming. Using reference parameters in these situations can make your code execute considerably faster.

TRY IT OUT: Pass-by-Reference

Let’s go back to a revised version of a very simple example, Ex5_03.cpp, to see how it would work using reference parameters:

// Ex5_07.cpp
// Using an lvalue reference to modify caller arguments
#include <iostream>
using std::cout;
using std::endl;
 
int incr10(int& num);               // Function prototype

int main()
{
  int num {3};
  int value {6};

  int result {incr10(num)};
  cout << endl  << "incr10(num) = " << result
       << endl << "num = " << num;
 
  result = incr10(value);
  cout << endl << "incr10(value) = " << result
       << endl << "value = " << value << endl;
  return 0;
}
 
// Function to increment a variable by 10
int incr10(int& num)                // Function with reference argument
{
  cout << endl << "Value received = " << num;
  num += 10;                        // Increment the caller argument
                                    //  - confidently
  return num;                       // Return the incremented value
}

This program produces the output:

Value received = 3
incr10(num) = 13
num = 13
Value received = 6
incr10(value) = 16
value = 16

How It Works

You should find the way this works quite remarkable. This is essentially the same as Ex5_03.cpp, except that the function uses an lvalue reference as a parameter. The prototype has been changed to reflect this. When the function is called, the argument is specified just as though it were a pass-by-value operation, so it’s used in the same way as the earlier version. The argument value isn’t passed to the function. The function parameter is initialized with the address of the argument, so whenever the parameter num is used in the function, it accesses the caller argument directly.

Just to reassure you that there’s nothing fishy about the use of the identifier num in main() as well as in the function, the function is called a second time with the variable value as the argument. At first sight, this may give you the impression that it contradicts what I said was a basic property of a reference — that after being declared and initialized, it couldn’t be reassigned to another variable. The reason it isn’t contradictory is that a reference as a function parameter is created and initialized each time the function is called, and is destroyed when the function ends, so you get a completely new reference created each time you use the function.

Within the function, the value received from the calling program is displayed onscreen. Although the statement is essentially the same as the one used to output the address stored in a pointer, because num is now a reference you obtain the data value rather than the address.

This clearly demonstrates the difference between a reference and a pointer. A reference is an alias for another variable, and therefore can be used as an alternative way of referring to it. It is equivalent to using the original variable name. The output shows that the incr10() function is directly modifying the variable passed as a caller argument.

You will find that if you try to use a numeric value, such as 20, as an argument to incr10(), the compiler outputs an error message. This is because the compiler recognizes that a reference parameter can be modified within a function, and the last thing you want is to have your constants changing value now and again. This would introduce a kind of excitement into your programs that you could probably do without. You also cannot use an expression for an argument corresponding to an lvalue reference parameter unless the expression is an lvalue. Essentially, the argument for an lvalue reference parameter must result in a persistent memory location in which something can be stored.

The security you get by using an lvalue reference parameter is all very well, but if the function didn’t modify the value, you wouldn’t want the compiler to create all these error messages every time you passed a reference argument that was a constant. Surely, there ought to be some way to accommodate this? As Ollie would have said, “There most certainly is, Stanley!”

Use of the const Modifier

You can apply the const modifier to a function parameter to tell the compiler that you don’t intend to modify it in any way. This causes the compiler to check that your code indeed does not modify the argument, and there are no error messages when you use a constant argument.

TRY IT OUT: Passing a const

You can modify the previous program to show how the const modifier changes the situation:

// Ex5_08.cpp
// Using a reference to modify caller arguments

#include <iostream>
using std::cout;
using std::endl;
 
int incr10(const int& num);              // Function prototype

int main()
{
  const int num {3};       // Declared const to test for temporary creation
  int value {6};
 
  int result {incr10(num)}
  cout << endl << "incr10(num) = " << result
       << endl << "num = " << num;
 
  result = incr10(value);
  cout << endl << "incr10(value) = " << result;
  cout << endl << "value = " << value;
 
  cout << endl;
  return 0;
}
 
// Function to increment a variable by 10
int incr10(const int& num)       // Function with const reference argument
{
  cout << endl << "Value received = " << num;
//   num += 10;                  // this statement would now be illegal
  return num+10;                 // Return the incremented value
}

The output when you execute this is:

Value received = 3
incr10(num) = 13
num = 3
Value received = 6
incr10(value) = 16
value = 6

How It Works

You declare the variable num in main() as const to show that when the parameter to the function incr10() is declared as const, you no longer get a compiler message when passing a const object.

It has also been necessary to comment out the statement that increments num in the function incr10(). If you uncomment this line, you’ll find the program no longer compiles, because the compiler won’t allow num to appear on the left of an assignment. When you specified num as const in the function header and prototype, you promised not to modify it, so the compiler checks that you kept your word. Everything works as before, except that the variables in main() are no longer changed by the function.

By using lvalue reference parameters, you now have the best of both worlds. On one hand, you can write a function that can access caller arguments directly and avoid the copying that is implicit in the pass-by-value mechanism. On the other hand, where you don’t intend to modify an argument, you can get all the protection against accidental modification you need by using a const modifier with an lvalue reference type.

Rvalue Reference Parameters

I’ll now illustrate briefly how parameters that are rvalue reference types differ from parameters that are lvalue reference types. Keep in mind that this won’t be how rvalue references are intended to be used. You’ll learn about that later in the book. Let’s look at an example that is similar to Ex5_07.cpp.

TRY IT OUT: Using rvalue Reference Parameters

Here’s the code for this example:

// Ex5_09.cpp
// Using an rvalue reference parameter
 
#include <iostream>
using std::cout;
using std::endl;
 
int incr10(int&& num);              // Function prototype
 
int main()
{
  int num {3};      
  int value {6};
  int result {};
/* 
  result = incr10(num);                              // Increment num
  cout << endl << "incr10(num) = " << result
       << endl << "num = " << num;
 
  result = incr10(value);                            // Increment value
  cout << endl << "incr10(value) = " << result
       << endl << "value = " << value;
*/ 
  result = incr10(value+num);                        // Increment an expression
  cout << endl << "incr10(value+num) = " << result
       << endl << "value = " << value;
 
  result = incr10(5);                                // Increment a literal
  cout << endl << "incr10(5) = " << result
       << endl << "5 = " << 5;
 
  cout << endl;
  return 0;
}
 
// Function to increment a variable by 10
int incr10(int&& num)       // Function with rvalue reference argument
{
  cout << endl << "Value received = " << num;
  num += 10;                  
  return num;               // Return the incremented value
}

Compiling and executing this produces the output:

Value received = 9
incr10(value+num) = 19
value = 6
Value received = 5
incr10(5) = 15
5 = 5

How It Works

The incr10() function now has an rvalue reference parameter type. In main(), you call the function with the expression value+num as the argument. The output shows that the function returns the value of the expression incremented by 10. Of course, you saw earlier that if you try to pass an expression as the argument for an lvalue reference parameter, the compiler will not allow it.

Next, you pass the literal, 5, as the argument, and again, the value returned shows the incrementing works. The output also shows that the literal 5 has not been changed, but why not? The argument in this case is an expression consisting of just the literal 5. The expression has the value 5 when it is evaluated, and this is stored in a temporary location that is referenced by the function parameter.

If you uncomment the statements at the beginning of main(), the code will not compile. A function that has an rvalue reference parameter can only be called with an argument that is an rvalue. Because num and value are lvalues, the compiler flags the statements that pass these as arguments to incr10() as errors.

While this example shows that you can pass an expression as the argument corresponding to an rvalue reference, and that within the function, the temporary location holding the value of the expression can be accessed and changed, this serves no purpose in this context. You will see when we get to look into defining classes that in some circumstances, rvalue reference parameters offer significant advantages.

Arguments to main()

You can define main() with no parameters or you can specify a parameter list that allows the main() function to obtain values from the command line from the execute command for the program. Values passed from the command line as arguments to main() are always interpreted as strings. If you want to get data into main() from the command line, you must define it like this:

int main(int argc, char* argv[])
{
  // Code for main()...
}

The first parameter is the count of the number of strings found on the command line, including the program name, and the second parameter is an array that contains pointers to these strings plus an additional element that is null. Thus, argc is always at least 1, because you at least must enter the name of the program. The number of arguments received depends on what you enter on the command line to execute the program. For example, suppose that you execute the DoThat program with the command:

DoThat.exe

There is just the name of the .exe file for the program, so argc is 1 and the argv array contains two elements — argv[0] pointing to the string "DoThat.exe", and argv[1] that contains nullptr.

Suppose you enter this on the command line:

DoThat or else "my friend" 999.9

Now argc is 5 and argv contains six elements, the last element being nullptr and the first five pointing to the strings:

"DoThat" "or" "else" "my friend" "999.9"

You can see from this that if you want to have a string that includes spaces received as a single string, you must enclose it between double quotes. You can also see that numerical values are read as strings, so if you want conversion to the numerical value, that is up to you.

Let’s see it working.

TRY IT OUT: Receiving Command-Line Arguments

This program just lists the arguments it receives from the command line:

// Ex5_10.cpp
// Reading command line arguments
#include <iostream>
using std::cout;
using std::endl;
        
int main(int argc, char* argv[])
{
  cout << endl << "argc = " << argc << endl;
  cout << "Command line arguments received are:" << endl;
  for(int i {}; i <argc; i++)
    cout << "argument " << (i+1) << ": " << argv[i] << endl;
  return 0;
}

You have two choices as to how you enter the command-line arguments. After you build the example, you can open a command window at the folder containing the .exe file, and then enter the program name followed by the command-line arguments. Alternatively, you can specify the command-line arguments in the IDE before you execute the program. Just open the project properties window by selecting Project Properties from the main menu and then extend the Configuration Properties tree in the left pane by clicking the arrow. Click the Debugging folder and enter the items to be passed to the application as values for the Command Arguments property.

I enter the following in the command window with the current directory containing the .exe file for the program:

Ex5_10 trying multiple "argument values" 4.5 0.0

Here is the output resulting from my input:

argc = 6
Command line arguments received are:
argument 1: Ex5_10
argument 2: trying
argument 3: multiple
argument 4: argument values
argument 5: 4.5
argument 6: 0.0

How It Works

The program first outputs the value of argc and then the values of each argument from the argv array in the for loop. You can see from the output that the first argument value is the program name. "argument values" is treated as a single argument because of the enclosing double quotes.

You could make use of the fact that the last element in argv is nullptr and code the output of the command-line argument values like this:

  int i{-1};
  while(argv[++i]
    cout << "argument " << (i+1) << ": " << argv[i] << endl;

The while loop ends when argv[argc] is reached because that element contains nullptr.

Accepting a Variable Number of Function Arguments

You can define a function so that it allows any number of arguments to be passed to it. You indicate that a variable number of arguments can be supplied by placing an ellipsis (which is three periods, ...) at the end of the parameter list in the function definition. For example:

int sumValues(int first,...)
{
  //Code for the function
}

There must be at least one ordinary parameter, but you can have more. The ellipsis must always be placed at the end of the parameter list.

Obviously, there is no information about the type or number of arguments in the variable list, so your code must figure out what is passed to the function when it is called. The C++ library defines va_start, va_arg, and va_end macros in the cstdarg header to help you do this. It’s easiest to show how these are used with an example.

TRY IT OUT: Receiving a Variable Number of Arguments

This program uses a function that just sums the values of a variable number of arguments passed to it:

// Ex5_11.cpp
// Handling a variable number of arguments
#include <iostream>
#include <cstdarg>
using std::cout;
using std::endl;
        
int sum(int count, ...)
{
  if(count <= 0) 
    return 0;
        
  va_list arg_ptr;                     // Declare argument list pointer
  va_start(arg_ptr, count);            // Set arg_ptr to 1st optional argument
        
  int sum {};
  for(int i {}; i<count; i++)
    sum += va_arg(arg_ptr, int);       // Add int value from arg_ptr and increment
        
  va_end(arg_ptr);                     // Reset the pointer to null
  return sum;
}
        
int main(int argc, char* argv[])
{
  cout << sum(6, 2, 4, 6, 8, 10, 12) << endl;
  cout << sum(9, 11, 22, 33, 44, 55, 66, 77, 66, 99) << endl;
  return 0;
}

This example produces the following output:

42
473

How It Works

The main() function calls the sum() function in the two output statements, in the first instance with seven arguments and in the second with ten arguments. The first argument in each case specifies the number of arguments that follow. It’s important not to forget this, because if you omit the count argument, the result will be rubbish.

The sum() function has a single normal parameter of type int that represents the count of the number of arguments that follow. The ellipsis in the parameter list indicates that an arbitrary number of arguments can be passed. Basically, you have two ways of determining how many arguments there are when the function is called — you can require that the number of arguments is specified by a fixed parameter, as in the case of sum(), or you can require that the last argument has a special marker value that you can check for and recognize.

To start processing the variable argument list, you declare a pointer of type va_list:

  va_list arg_ptr;                     // Declare argument list pointer

The va_list type is defined in the cstdarg header file, and the pointer is used to point to each argument in turn.

The va_start macro is used to initialize arg_ptr so that it points to the first argument in the list:

  va_start(arg_ptr, count);            // Set arg_ptr to 1st optional argument

The second argument to the macro is the name of the fixed parameter that precedes the ellipsis in the parameter list, and this is used by the macro to determine where the first variable argument is.

You retrieve the values of the arguments in the list in the for loop:

  int sum {};
  for(int i {} ; i<count; i++)
    sum += va_arg(arg_ptr, int);      // Add int value from arg_ptr and increment

The va_arg macro returns the value of the argument at the location specified by arg_ptr and increments arg_ptr to point to the next argument value. The second argument to the va_arg macro is the argument type, and this determines the value that you get as well as how arg_ptr increments, so if this is not correct, you get chaos; the program probably executes, but the values you retrieve are rubbish, and arg_ptr is incremented incorrectly to access more rubbish.

When you are finished retrieving argument values, you reset arg_ptr with the statement:

  va_end(arg_ptr);                     // Reset the pointer to null

The va_end macro resets the pointer of type va_list that you pass as the argument to it to null. It’s a good idea to always do this because after processing the arguments, arg_ptr points to a location that does not contain valid data.

RETURNING VALUES FROM A FUNCTION

All the example functions that you have created have returned a single value. Is it possible to return anything other than a single value? Well, not directly, but as I said earlier, the single value returned need not be a numeric value; it could also be an address, which provides the key to returning any amount of data. You simply use a pointer. Unfortunately, this also is where the pitfalls start, so you need to keep your wits about you for the adventure ahead.

Returning a Pointer

Returning a pointer value is easy. A pointer value is just an address, so if you want to return the address of some variable value, you can just write the following:

return &value;                     // Returning an address

As long as the function header and function prototype indicate the return type appropriately, you have no problem — or at least, no apparent problem. Assuming that the variable value is of type double, the prototype of a function called treble, which might contain the preceding return statement, could be as follows:

double* treble(double data);

I have defined the parameter list arbitrarily here.

So let’s look at a function that returns a pointer. It’s only fair that I warn you in advance — this function doesn’t work, but it is educational. Let’s assume that you need a function that returns a pointer to a memory location containing three times its argument value. Our first attempt to implement such a function might look like this:

// Function to treble a value - mark 1
double* treble(double data)
{
  double result {};
  result = 3.0*data;
  return &result;
}

TRY IT OUT: Returning a Bad Pointer

You could create a little test program to see what happens (remember that the treble function won’t work as expected):

// Ex5_12.cpp
#include <iostream>
using std::cout;
using std::endl;
        
double* treble (double);                 // Function prototype
        
int main()
{
  double num {5.0};                      // Test value
  double* ptr {};                        // Pointer to returned value
        
  ptr = treble(num);
        
   out << endl << "Three times num = " << 3.0*num;
        
  cout << endl << "Result = " << *ptr;   // Display 3*num
        
  cout << endl;
  return 0;
}
        
// Function to treble a value - mark 1
double* treble(double data)
{
  double result {};
  result = 3.0*data;
  return &result;
}

There’s a hint that everything is not as it should be, because compiling this program results in a warning from the compiler:

warning C4172: returning address of local variable or temporary

The output that I got from executing the program was:

Three times num = 15
Result = 4.10416e-230

How It Works (or Why It Doesn’t)

The function main() calls treble() and stores the address returned in the pointer ptr, which should point to a value that is three times the argument, num. It then displays the result of computing three times num, followed by the value at the address returned from the function.

Clearly, the second line of output doesn’t reflect the correct value of 15, but where’s the error? Well, it’s not exactly a secret because the compiler gives fair warning of the problem. The error arises because the variable result in the function treble() is created when the function begins execution, and is destroyed on exiting from the function — so the memory that the pointer is pointing to no longer contains the original variable value. The memory previously allocated to result becomes available for other purposes, and here, it has evidently been used for something else.

A Cast-Iron Rule for Returning Addresses

There is an absolutely cast-iron rule for returning addresses:

Never, ever, return the address of a local automatic variable from a function.

You obviously can’t use a function that doesn’t work, so what can you do to rectify that? You could use a reference parameter and modify the original variable, but that’s not what you set out to do. You are trying to return a pointer to some useful data so that, ultimately, you can return more than a single item of data. One answer lies in dynamic memory allocation (you saw this in action in the previous chapter). With the operator new, you can create a new variable in the free store that continues to exist until it is eventually destroyed by delete — or until the program ends. With this approach, the function looks like this:

// Function to treble a value - mark 2
double* treble(double data)
{
  double* result {new double{}};
  *result = 3.0*data;
  return result;
}

Rather than declaring result to be type double, you now declare it to be of type double* and store in it the address returned by the operator new. Because the result is a pointer, the rest of the function is changed to reflect this, and the address contained in the result is finally returned to the calling program. You could exercise this version by replacing the function in the last working example with this version.

You need to remember that with dynamic memory allocation from within a function such as this, more memory is allocated each time the function is called. The onus is on the calling program to delete the memory when it’s no longer required. It’s easy to forget to do this in practice, with the result that the free store is gradually eaten up until, at some point, it is exhausted and the program fails. As mentioned before, this sort of problem is referred to as a memory leak.

Here you can see how the function would be used. The only necessary change to the original code is to use delete to free the memory as soon as you have finished with the pointer returned by the treble() function.

#include <iostream>
        
using std::cout;
using std::endl;
        
double* treble(double);                  // Function prototype
        
int main()
{
  double num {5.0};                      // Test value
  double* ptr {};                        // Pointer to returned value
        
  ptr = treble(num);
        
  cout << endl << "Three times num = " << 3.0*num;
        
  cout << endl << "Result = " << *ptr;   // Display 3*num
  delete ptr;                            // Don't forget to free the memory
  ptr = nullptr;
  cout << endl;
  return 0;
}
        
// Function to treble a value - mark 2
double* treble(double data)
{
  double* result {new double{}}
  *result = 3.0*data;
  return result;
}

Returning a Reference

You can also return an lvalue reference from a function. This is just as fraught with potential errors as returning a pointer, so you need to take care with this, too. Because an lvalue reference has no existence in its own right (it’s always an alias for something else), you must be sure that the object that it refers to still exists after the function completes execution. It’s very easy to forget this when you use references in a function because they appear to be just like ordinary variables.

References as return types are of primary significance in the context of object-oriented programming. As you will see later in the book, they enable you to do things that would be impossible without them. (This particularly applies to “operator overloading,” which I’ll come to in Chapter 8.) Returning an lvalue reference from a function means that you can use the result of the function on the left side of an assignment statement.

TRY IT OUT: Returning a Reference

Let’s look at an example that illustrates the use of reference return types, and also demonstrates how a function can be used on the left of an assignment operation when it returns an lvalue. This example assumes that you have an array containing a mixed set of values. Whenever you want to insert a new value into the array, you want to replace the element with the lowest value.

// Ex5_13.cpp
// Returning a reference
#include <iostream>
#include <iomanip>
using std::cout;
using std::endl;
using std::setw;
        
double& lowest(double values[], int length); // Function prototype
        
int main()
{
 
  double data[] { 3.0, 10.0, 1.5, 15.0, 2.7, 23.0,
                  4.5, 12.0, 6.8, 13.5, 2.1, 14.0 };
  int len {_countof(data)}                   // Number of elements       
  for(auto value : data)
     cout << setw(6) << value;
        
  lowest(data, len) = 6.9;                   // Change lowest to 6.9
  lowest(data, len) = 7.9;                   // Change lowest to 7.9
        
  cout << endl;
  for (auto value : data)
     cout << setw(6) << value;
        
  cout << endl;
  return 0;
}
        
// Function returning a reference
double& lowest(double a[], int len)
{
  int j {};                                  // Index of lowest element
  for(int i {1}; i < len; i++)
     if(a[j] > a[i])                         // Test for a lower value...
        j = i;                               // ...if so update j
  return a[j];                               // Return reference to lowest element
}

The output from this example is:

     3    10   1.5    15   2.7    23   4.5    12   6.8  13.5   2.1    14
     3    10   6.9    15   2.7    23   4.5    12   6.8  13.5   7.9    14

How It Works

Let’s first look at how the function is implemented. The prototype for the function lowest() uses double& as the specification of the return type, which is therefore of type “reference to double.” You write a reference type return value in exactly the same way as you have seen for variable declarations, by appending & to the data type. The function has two parameters — a one-dimensional array of type double and a parameter of type int that specifies the length of the array.

The body of the function has a straightforward for loop to determine which element of the array passed contains the lowest value. The index, j, of the array element with the lowest value is arbitrarily set to 0 at the outset, and then modified within the loop if the current element, a[i], is less than a[j]. Thus, on exit from the loop, j contains the index value corresponding to the array element with the lowest value. The return statement is:

   return a[j];                    // Return reference to lowest element

In spite of the fact that this looks identical to the statement that would return a value, because the return type was declared as a reference, this returns a reference to the array element a[j] rather than the value that the element contains. The address of a[j] is used to initialize the reference to be returned. This reference is created by the compiler because the return type was declared as a reference.

Don’t confuse returning &a[j] with returning a reference. If you write &a[j] as the return value, you are specifying the address of a[j], which is a pointer. If you do this after having specified the return type as a reference, you get an error message from the compiler. Specifically, you get this:

 error C2440: 'return' : cannot convert from 'double * ' to 'double &'

The function main(), which exercises the lowest() function, is very simple. An array of type double is declared and initialized with 12 arbitrary values, and an int variable len is initialized to the length of the array using the _countof() macro. The initial values in the array are output for comparison purposes.

Again, the program uses the stream manipulator setw() to space the values uniformly, requiring the #include directive for iomanip.

The function main() then calls the function lowest() on the left of an assignment to change the lowest value in the array. This is done twice to show that it does actually work and is not an accident. The contents of the array are then output to the display again, with the same field width as before, so corresponding values line up.

As you can see from the output with the first call to lowest(), the third element of the array, data[2], contained the lowest value, so the function returned a reference to it and its value was changed to 6.9. Similarly, on the second call, data[10] was changed to 7.9. This demonstrates quite clearly that returning a reference allows the use of the function on the left of an assignment. The effect is as if the variable specified in the return statement appeared on the left of the assignment.

Of course, if you want to, you can also use it on the right of an assignment, or in any other suitable expression. If you had two arrays, X and Y, with the number of array elements specified by lenx and leny, respectively, you could set the lowest element in the array x to twice the lowest element in the array y with this statement:

lowest(x, lenx) = 2.0*lowest(y, leny);

This statement would call lowest() twice — once with arguments y and leny in the expression on the right of the assignment, and once with arguments x and lenx to obtain the address where the result of the right-hand expression is to be stored.

A Cast-Iron Rule: Returning References

A similar rule to the one concerning the return of a pointer from a function also applies to returning references:

Never, ever, return a reference to a local variable from a function.

I’ll leave the topic of returning a reference from a function for now, but I haven’t finished with it yet. I will come back to it again in the context of user-defined types and object-oriented programming, when you will unearth a few more magical things that you can do with references.

Static Variables in a Function

There are some things you can’t do with automatic variables within a function. You can’t count how many times a function is called, for example, because you can’t accumulate a value from one call to the next. There’s more than one way to get around this. For instance, you could use a reference parameter to update a count in the calling program, but this wouldn’t help if the function was called from lots of different places within a program. You could use a global variable that you incremented from within the function, but globals are risky things to use. Because globals can be accessed from anywhere in a program, it is very easy to change them accidentally.

Global variables are also risky in applications that have multiple threads of execution that access them, and you must take special care to manage how globals are accessed from different threads. The basic problem that has to be addressed when more than one thread can access a global variable is that one thread can change the value of a global variable while another thread is working with it. The best solution in such circumstances is to avoid the use of global variables altogether.

To create a variable whose value persists from one call of a function to the next, you can declare a variable within a function as static. You use exactly the same form of declaration for a static variable that you saw in Chapter 2. For example, to declare a variable count as static, you could use this statement:

static int count {};

This also initializes the variable to zero.

TRY IT OUT: Using Static Variables in Functions

You can demonstrate how a static variable behaves in a function with the following simple example:

// Ex5_14.cpp
// Using a static variable within a function
#include <iostream>
using std::cout;
using std::endl;
        
void record();      // Function prototype, no arguments or return value
        
int main()
{
  record();
        
  for(int i {}; i <= 3; i++)
     record();
        
  cout << endl;
  return 0;
}
        
// A function that records how often it is called
void record()
{
  static int count {};
  cout << endl << "This is the " << ++count;
  if((count > 3) && (count < 21))         // All this....
     cout <<"th";
  else
     switch(count%10)                     // is just to get...
     {
     case 1: cout << "st";
             break;
     case 2: cout << "nd";
             break;
     case 3: cout << "rd";
             break;
     default: cout << "th";               // the right ending for...
     }                                    // 1st, 2nd, 3rd, 4th, etc.
   cout << " time I have been called";
   return;
}

Our function here serves only to record the fact that it was called. If you build and execute it, you get this output:

This is the 1st time I have been called
This is the 2nd time I have been called
This is the 3rd time I have been called
This is the 4th time I have been called
This is the 5th time I have been called

How It Works

You initialize the static variable count with 0 and increment it in the first output statement in the function. Because the increment operator is prefixed, the incremented value is displayed by the output statement. It will be 1 on the first call, 2 on the second, and so on. Because count is static, it continues to exist and retain its value from one call of the function to the next.

The remainder of the function is concerned with working out when "st", "nd", "rd", or "th" should be appended to the value of count that is displayed. It’s surprisingly irregular.

Note the return statement. Because the return type of the function is void, to include a value would cause a compiler error. You don’t actually need to put a return statement in this particular case, because running off the closing brace for the body of the function is equivalent to executing a return statement without a value. The program would compile and run without error even if you didn’t include the return.

RECURSIVE FUNCTION CALLS

When a function contains a call to itself, it’s referred to as a recursive function. A recursive function call can also be indirect, where a function fun1 calls a function fun2, which, in turn, calls fun1.

Recursion may seem to be a recipe for an indefinite loop, and if you aren’t careful, it certainly can be. An indefinite loop will lock up your machine and require Ctrl+Alt+Del to end the program, which is always a nuisance. A prerequisite for avoiding an indefinite loop is that the function contains some means of stopping the process.

Unless you have come across the technique before, the sort of things to which recursion may be applied may not be obvious. In physics and mathematics, there are many things that can be thought of as involving recursion. A simple example is the factorial of an integer, which, for a given integer N, is the product 1 × 2 × 3 . . . × N. This is very often the example given to show recursion in operation. Recursion can also be applied to the analysis of programs during the compilation process; however, you will look at something even simpler.

TRY IT OUT: A Recursive Function

At the start of this chapter (see Ex5_01.cpp), you produced a function to compute the integral power of a value; that is, to compute xⁿ. This is equivalent to x multiplied by itself n times. You can implement this as a recursive function as an elementary illustration of recursion in action. You can also improve the implementation of the function to deal with negative index values, where x^-n is equivalent to 1/xⁿ.

// Ex5_15.cpp (based on Ex5_01.cpp)
// A recursive version of x to the power n
#include <iostream>
using std::cout;
using std::endl;
        
double power(double x, int n);    // Function prototype
        
int main()
{
  double x {2.0};                 // Different x from that in function power
  double result {};
        
  // Calculate x raised to powers -3 to +3 inclusive
  for(int index {-3}; index <= 3; index++)
    cout << x << " to the power " << index << " is " << power(x, index)<< endl;
        
  return 0;
}
        
// Recursive function to compute integral powers of a double value
// First argument is value, second argument is power index
double power(double x, int n)
{
  if(n < 0)
  {
     x = 1.0/x;
     n = -n;
  }
  if(n > 0)
     return x*power(x, n-1);
  else
     return 1.0;
}

The output from this program is:

2 to the power -3 is 0.125
2 to the power -2 is 0.25
2 to the power -1 is 0.5
2 to the power 0 is 1
2 to the power 1 is 2
2 to the power 2 is 4
2 to the power 3 is 8

How It Works

The function now supports positive and negative powers of x, so the first action is to check whether the value for the power that x is to be raised to, n, is negative:

   if(n < 0)
   {
     x = 1.0/x;
     n = -n;
   }

Supporting negative powers is easy; the code just uses the fact that x^-n can be evaluated as (1/x)ⁿ. Thus, if n is negative, you set x to be 1.0/x and change the sign of n so it’s positive.

The next if statement decides whether or not the power() function should call itself once more:

   if(n > 0)
     return x*power(x, n-1);
   else
     return 1.0;

The if statement provides for the value 1.0 being returned if n is zero, and in all other cases, it returns the result of the expression, x*power(x, n-1). This causes a further call to the function power() with the index value reduced by 1. Thus, the else clause in the if statement provides the essential mechanism necessary to avoid an indefinite sequence of recursive function calls.

Clearly, if the value of n is other than zero within the function power(), a further call to power()occurs. In fact, for any given value of n other than 0, the function calls itself n times, ignoring the sign of n. Figure 5-4 shows the mechanism when the index argument is 3.

FIGURE 5-4

As you see, the power() function is called a total of four times to generate x³, three of the calls being recursive where the function is calling itself.

Using Recursion

Unless you have a problem that particularly lends itself to using recursive functions, or if you have no obvious alternative, it’s generally better to use a different approach, such as a loop, because it will be much more efficient than using recusion. Think about what happens with our last example to evaluate a simple product, x multiplied by itself n times. On each call, the compiler generates copies of the two arguments to the function, and also has to keep track of the location to return to when each return is executed. It’s also necessary to arrange to save the contents of various registers in your computer so that they can be used within power(), and, of course, these need to be restored to their original state at each return from the function. With a quite modest depth of recursive call, the overhead will be considerably greater than if you use a loop.

This is not to say you should never use recursion. Where the problem suggests the use of recursive function calls as a solution, it can be an immensely powerful technique, greatly simplifying the code. You’ll see an example where this is the case in the next chapter.

SUMMARY

In this chapter, you learned about the basics of program structure. You should have a good grasp of how functions are defined, how data can be passed to a function, and how results are returned to a calling program. Functions are fundamental to programming in C++, so everything you do from here on will involve using multiple functions in a program.

The use of references as arguments is a very important concept, so make sure you are confident about using them. You’ll see a lot more about references as arguments to functions when you look into object-oriented programming.

EXERCISES

The factorial of 4 (written as 4!) is 4 × 3 × 2 × 1 = 24, and 3! is 3 × 2 × 1 = 6, so it follows that 4! is 4 × 3!, or more generally:
```
fact(n) = n*fact(n - 1)
```
1. The limiting case is when n is 1, in which case, 1! = 1. Because of this, 0! is defined to be 1. Write a recursive function that calculates factorials, and test it.
Write a function that swaps two integers, using pointers as arguments. Write a program that uses this function and test that it works correctly.
The trigonometry functions (sin(), cos(), and tan()) in the standard cmath library take arguments in radians. Write three equivalent functions, called sind(), cosd(), and tand(), which take arguments in degrees. All arguments and return values should be type double.
Write a program that reads a number (an integer) and a name (less than 15 characters) from the keyboard. Design the program so that the data entry is done in one function, and the output in another. Store the data in the main() function. The program should end when zero is entered for the number. Think about how you are going to pass the data between functions — by value, by pointer, or by reference?
(Advanced) Write a function that, when passed a string consisting of words separated by single spaces, returns the first word; calling it again with an argument of nullptr returns the second word, and so on, until the string has been processed completely, when nullptr is returned. This is a simplified version of the way the C run-time library routine strtok() works. So, when passed the string "one two three", the function returns "one" after the first call, then "two" after the second, and finally "three". Passing it a new string results in the current string being discarded before the function starts on the new string.

WHAT YOU LEARNED IN THIS CHAPTER

TOPIC	CONCEPT
Functions	Functions should be compact units of code with a well-defined purpose. A typical program will consist of a large number of small functions, rather than a small number of large functions.
Function prototypes	Always provide a function prototype for each function defined in your program, positioned before you call that function.
Reference parameters	Passing values to a function using a reference can avoid the copying implicit in the pass-by-value transfer of arguments. Parameters that are not modified in a function should be specified as `const`.
Returning references or pointers	When returning a reference or a pointer from a function, ensure that the object being returned has the correct scope. Never return a pointer or a reference to an object that is local to a function.
`static` variables in a function	A static variable that is defined within the body of a function retains its value from one function call to the next.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.

Table of Contents for Chapter 5: Introducing Structure into Your Programs

Create new playlist

Sign In

Sign Up

UNDERSTANDING FUNCTIONS

Why Do You Need Functions?

Structure of a Function

The Function Header

The General Form of a Function Header

The Function Body

The return Statement

Alternative Function Syntax

Using a Function

Function Prototypes

PASSING ARGUMENTS TO A FUNCTION

The Pass-by-Value Mechanism

Pointers as Arguments to a Function

Passing Arrays to a Function

Passing Multidimensional Arrays to a Function

References as Arguments to a Function

Use of the const Modifier

Rvalue Reference Parameters

Arguments to main()

Accepting a Variable Number of Function Arguments

RETURNING VALUES FROM A FUNCTION

Returning a Pointer

A Cast-Iron Rule for Returning Addresses

Returning a Reference

A Cast-Iron Rule: Returning References

Static Variables in a Function

RECURSIVE FUNCTION CALLS

Using Recursion

SUMMARY

EXERCISES

WHAT YOU LEARNED IN THIS CHAPTER

Table of Contents for
Chapter 5: Introducing Structure into Your Programs