lafore_robert_objectoriented_programming_in_c

Chapter 5

196

FIGURE 5.9

Functions versus inline code.

Long sections of repeated code are generally better off as normal functions: The savings in memory space is worth the comparatively small sacrifice in execution speed. But making a short section of code into an ordinary function may result in little savings in memory space, while imposing just as much time penalty as a larger function. In fact, if a function is very short, the instructions necessary to call it may take up as much space as the instructions within the function body, so that there is not only a time penalty but a space penalty as well.

In such cases you could simply repeat the necessary code in your program, inserting the same group of statements wherever it was needed. The trouble with repeatedly inserting the same code is that you lose the benefits of program organization and clarity that come with using functions. The program may run faster and take less space, but the listing is longer and more complex.

The solution to this quandary is the inline function. This kind of function is written like a normal function in the source file but compiles into inline code instead of into a function. The source file remains well organized and easy to read, since the function is shown as a separate entity. However, when the program is compiled, the function body is actually inserted into the program wherever a function call occurs.

Chapter 5

198

Here’s an example, a variation on the OVERLOAD program that demonstrates this effect. In OVERLOAD we used three different functions with the same name to handle different numbers of arguments. The present example, MISSARG, achieves the same effect in a different way.

//missarg.cpp

//demonstrates missing and default arguments #include <iostream>

using namespace std;

In this program the function repchar() takes two arguments. It’s called three times from main(). The first time it’s called with no arguments, the second time with one, and the third time with two. Why do the first two calls work? Because the called function provides default arguments, which will be used if the calling program doesn’t supply them. The default arguments are specified in the declaration for repchar():

void repchar(char=’*’, int=45); //declaration

The default argument follows an equal sign, which is placed directly after the type name. You can also use variable names, as in

void repchar(char reptChar=’*’, int numberReps=45);

If one argument is missing when the function is called, it is assumed to be the last argument. The repchar() function assigns the value of the single argument to the ch parameter and uses the default value 45 for the n parameter.

If both arguments are missing, the function assigns the default value ‘*’ to ch and the default value 45 to n. Thus the three calls to the function all work, even though each has a different number of arguments.

Variables may be defined inside main() or inside other functions; the effect is the same, since main() is a function. Variables defined within a function body are called local variables because they have local scope. However, they are also sometimes called automatic variables, because they have the automatic storage class.

Let’s look at these two important characteristics of variables that are defined within functions.

Storage Class

A local variable is not created until the function in which it is defined is called. (More accurately, we can say that variables defined within any block of code are not created until the block is executed. Thus variables defined within a loop body only exist while the loop is executing.) In the program fragment just given, the variables somevar and othervar don’t exist until the somefunc() function is called. That is, there is no place in memory where their values can be stored; they are undefined. When control is transferred to somefunc(), the variables are created and memory space is set aside for them. Later, when somefunc() returns and control is passed back to the calling program, the variables are destroyed and their values are lost. The name automatic is used because the variables are automatically created when a function is called and automatically destroyed when it returns.

The time period between the creation and destruction of a variable is called its lifetime (or sometimes its duration). The lifetime of a local variable coincides with the time when the function in which it is defined is executing.

The idea behind limiting the lifetime of variables is to save memory space. If a function is not executing, the variables it uses during execution are presumably not needed. Removing them frees up memory that can then be used by other functions.

Scope

A variable’s scope, also called visibility, describes the locations within a program from which it can be accessed. It can be referred to in statements in some parts of the program; but in others, attempts to access it lead to an unknown variable error message. The scope of a variable is that part of the program where the variable is visible.

Variables defined within a function are only visible, meaning they can only be accessed, from within the function in which they are defined. Suppose you have two functions in a program:

Chapter 5

202

Global Variables

The next kind of variable is global. While local variables are defined within functions, global variables are defined outside of any function. (They’re also defined outside of any class, as we’ll see later.) A global variable is visible to all the functions in a file (and potentially in other files). More precisely, it is visible to all those functions that follow the variable’s definition in the listing. Usually you want global variables to be visible to all functions, so you put their declarations at the beginning of the listing. Global variables are also sometimes called external variables, since they are defined external to any function.

Here’s a program, EXTERN, in which three functions all access a global variable.

//extern.cpp

//demonstrates global variables #include <iostream>

using namespace std;

Chapter 5

204

Static Local Variables

Let’s look at another kind of variable: the static local variable. There are static global variables, but they are meaningful only in multifile programs, which we don’t examine until Chapter 13.

A static local variable has the visibility of an automatic local variable (that is, inside the function containing it). However, its lifetime is the same as that of a global variable, except that it doesn’t come into existence until the first call to the function containing it. Thereafter it remains in existence for the life of the program.

Static local variables are used when it’s necessary for a function to remember a value when it is not being executed; that is, between calls to the function. In the next example, a function, getavg(), calculates a running average. It remembers the total of the numbers it has averaged before, and how many there were. Each time it receives a new number, sent as an argument from the calling program, it adds this number to the total, adds 1 to a count, and returns the new average by dividing the total by the count. Here’s the listing for STATIC:

//static.cpp

//demonstrates static variables #include <iostream>

using namespace std;

int main()

{

float data=1, avg;

while( data != 0 )

{

cout << “Enter a number: “; cin >> data;

avg = getavg(data);

cout << “New average is “ << avg << endl;

}

return 0;

}

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

//getavg()

//finds average of old plus new data float getavg(float newdata)

{

static float total = 0; //static variables are initialized