The for statement is similar to a set of curly braces in that you can declare variables inside the statement whose scope goes from the start of the for to the end of the statement. (This includes the statement or block controlled by the for.) In the following statement:

for (int count = 0; count < MAX; ++count)
    sum += count;
// count is out of scope from here on.

the variable count is declared inside the for. Its scope is to the end of the statement; the scope ends with the first semicolon after the for.

We started out using the object std::cout for output. What this actually means is that we are using the variable cout in the namespace std. This namespace is used by C++ to define its standard library objects and functions.

You may remember that we began most of our programs with the statement:

#include <iostream>

The first statement causes the compiler to read in a file called iostream, which contains the definitions of the C++ standard variables. For example, a simplified iostream might look like this:

namespace std {
    istream cin;   // Define the input stream cin
    ostream cout;  // Define the output stream cout
    ostream cerr;  // Define the standard error stream
   // Lots of other stuff
}

Once the compiler has seen these definitions, std::cin, std::cout, and std::cerr are available for our use.

If you do not enclose your code or variables in any namespace, a blank namespace is assigned to them. For example, the expression:

::global = 45;

assigns 45 to the variable global, which was declared outside any namespace declaration.

Let’s suppose you want to define a module and you want most of the functions and variables in the file to exist in their own unique namespace.

You could put the following statement at the top of your file:

namespace my_file_vars {

But what happens if, by some strange quirk of fate, someone else defines a namespace with the same name? The result is a namespace collision.

To avoid this, C++ has invented the unnamed namespace. The declaration:

namespace {

with no name specified, puts all the enclosed declarations in a namespace unique to the file.

Namespaces may be nested. For example, we could declare some variables as follows:

namespace core {
    namespace games {
       namespace dice {
          int roll;    // The value of the last roll

Nesting this deep is a little verbose (core::games::dice::roll), but if you have a lot of code to organize, nested namespaces may be useful.

Let’s assume we have a program with a command module (with the namespace command) and a command parsing module (with the namespace command_parser). These two modules are very closely related, and the command module makes frequent references to variables inside the parsing module. (We’ll also ignore the fact that tight coupling like this is a bad design.)

When writing the command module, if you want to refer to a variable in the parsing module, you have to prefix it with the namespace identifier:

if (command_parser::first_argument == "ShowAll")

Because these modules are tightly coupled, you have to write out command_parser::first_argument a lot of times. This can get tiring after a while.

But you can tell C++, “I know that first_argument is in the command_parser module, but pretend that it’s in mine too.” This is accomplished through the using statement:

using command_parser::first_argument;

C++ will now let you use the name first_argument instead of command_parser::first_argument.

using command_parser::first_argument;

if (first_argument == "ShowAll")

Now let’s suppose there are a lot of variables that we wish to import from the module command_parser. We could put a using statement in our code for each one, but this would require a lot of statements. Or we can do things wholesale and tell C++ that all the names in the namespace command_parser are to be imported into our module. This is done with the statement:

using namespace command_parser;

The keyword void is also used to indicate a function that does not return a value (similar to the FORTRAN SUBROUTINE or PASCAL Procedure). For example, this function just prints a result; it does not return a value:

void print_answer(int answer) 
{ 
    if (answer < 0) { 
        std::cout << "Answer corrupt
"; 
        return; 
    } 
    std::cout << "The answer is " << answer '
'; 
}

Namespaces affect not only variables but functions as well. A function belongs to the namespace in which it is declared. For example:

namespace math {

int square(const int i) {
    return (i * i);
}

} // End namespace

namespace body {

int print_value(  )
{
    std::cout << "5 squared is " << math::square(5) << '
';
}

}

All the functions in a namespace can access the variables in that namespace directly and don’t need a using clause or a namespace qualification. For example:

namespace math {

const double PI = 3.14159;

double area(const double radius)
{
    return (2.0 * PI * radius);
}

}

A parameter declared const cannot be changed inside the function. Ordinary parameters can be changed inside functions, but the changes will not be passed back to the calling program.

For example, in the triangle function, we never change width or height. These could easily be declared const. Since the return value is also something that cannot be changed, it can be declared const as well. The const declarations serve to notify the programmer that the parameters do not change inside the function. If you do attempt to change a const parameter, the compiler generates an error. The improved triangle function with the const declarations can be seen in Example 9-4.

const float triangle(const float width, const float height)
{
    float area; // area of the triangle 

    assert(width >= 0.0);
    assert(height >= 0.0);
    area = width * height / 2.0;
    return (area);
}

As it stands now, the const declaration for the return value is merely a decoration. In the next section you’ll see to how to return references and make the const return declaration useful.

Remember that in Chapter 5 we discussed reference variables. A reference variable is a way of declaring an additional name for a variable. For global and local variables, reference variables are not very useful. However, they take on an entirely new meaning when used as parameters.

Suppose you want to write a subroutine to increment a counter. If you write it like Example 9-5, it won’t work.

#include <iostream>

// This function won't work
void inc_counter(int counter)
{
    ++counter;
}

int main(  )
{
   int a_count = 0;     // Random counter

   inc_counter(a_count);
   std::cout << a_count << '
';
   return (0);
}

Why doesn’t it work? Because C++ defaults to call by value. This means that values go in, but they don’t come out.

What happens if you convert the parameter counter to a reference? References are just another way of giving the same variable two names. When inc_counter is called, counter becomes a reference to a_count. Thus, anything done to counter results in changes to a_count. Example 9-6, using a reference parameter, works properly.

#include <iostream>

// Works
void inc_counter(int& counter)
{
    ++counter;
}

int main(  )
{
   int a_count = 0;     // Random counter

   inc_counter(a_count);
   std::cout << a_count << '
';
   return (0);
}

Reference declarations can also be used for return values. Example 9-7 finds the biggest element in an array.

int& biggest(int array[], int n_elements)
{
    int index;  // Current index
    int biggest; // Index of the biggest element

    // Assume the first is the biggest
    biggest = 0;
    for (index = 1; index < n_elements; ++index) {
        if (array[biggest] < array[index])
            biggest = index;
    }

    return (array[biggest]);
}

If you wanted to print the biggest element of an array, all you would have to do is this:

int item_array[5] = {1, 2, 5000, 3, 4}; // An array

std::cout << "The biggest element is " << 
         biggest(item_array, 5) << '
';

Let’s examine this in more detail. First of all, consider what happens when you create a reference variable:

int& big_reference = item_array[2]; // A reference to element #2

The reference variable big_reference is another name for item_array[2]. You can now use this reference to print a value:

std::cout << big_reference << '
';   // Print out element #2

But since this is a reference, you can use it on the left side of an assignment statement as well. (Expressions that can be used on the left side of the = in an assignment are called lvalues.)

big_reference = 0;      // Zero the largest value of the array

The function biggest returns a reference to item_array[2]. Remember that in the following code, biggest( ) is item_array[2]. The following three code sections all perform equivalent operations. The actual variable, item_array[2], is used in all three:

// Using the actual data
std::cout << item_array[2] << '
';
item_array[2] = 0;

// Using a simple reference
int big_reference = &item_array[2];
std::cout << big_reference << '
';
big_reference = 0;

// Using a function that returns a reference
std::cout << biggest(  ) << '
';  
biggest(  ) = 0;

Because biggest returns a reference, it can be used on the left side of an assignment operation (=). But suppose you don’t want that to happen. You can accomplish this by returning a const reference:

const int& biggest(int array[], int n_elements);

This tells C++ that even though you return a reference, the result cannot be changed. Thus, code like the following is illegal:

biggest(  ) = 0;              // Now it generates an error

Be careful when using return by reference, or you could wind up with a reference to a variable that no longer exists. Example 9-8 illustrates this problem.

 1: const int& min(const int& i1, const int& i2)
 2: {
 3:     if (i1 < i2)
 4:         return (i1);
 5:     return (i2);
 6: }
 7: 
 8: int main(  )
 9: {
10:    const int& i = min(1+2, 3+4);
11: 
12:    return (0);
13: }

Line 1 starts the definition of the function min. It returns a reference to the smaller of two integers.

In line 10 we call this function. Before the function min is called, C++ creates a temporary integer variable to hold the value of the expression 1 + 2. A reference to this temporary variable is passed to the min function as the parameter i1. C++ creates another temporary variable for the i2 parameter.

The function min is then called and returns a reference to i1. But what does i1 refer to? It refers to a temporary variable that C++ created in main. At the end of the statement, C++ can destroy all the temporaries.

Let’s look at the call to min (line 10) in more detail. Here’s a pseudo-code version of line 10, including the details that C++ normally hides from the programmer:

create integer tmp1, assign it the value 1 + 2
create integer tmp2, assign it the value 3 + 4
bind parameter i1 so it refers to tmp1
bind parameter i2 so it refers to tmp2
call the function "min"
bind main's variable i so it refers to 
        the return value (i1-a reference to tmp1)
// At this point i is a reference to tmp1
destroy tmp1 
destroy tmp2

//    At this point i still refers to tmp1
//    It doesn't exist, but i refers to it

At the end of line 10 we have a bad situation: i refers to a temporary variable that has been destroyed. In other words, i points to something that does not exist. This is called a dangling reference and should be avoided.

So far you’ve dealt only with simple parameters. C++ treats arrays a little differently. First of all, you don’t have to put a size in the prototype declaration. For example:

int sum(int array[]);

C++ uses a parameter-passing scheme called “call by address” to pass arrays. Another way of thinking of this is that C++ automatically turns all array parameters into reference parameters. This allows any size array to be passed. The function sum we just declared may accept integer arrays of length 3, 43, 5,000, or any length.

However, you can put in a size if you want to. C++ allows this, although it ignores whatever number you put there. But by putting in the size, you alert the people reading your program that this function takes only fixed-size arrays.

int sum(int array[3]);

For multidimensional arrays you are required to put in the size for each dimension except the last one. That’s because C++ uses these dimensions to compute the location of each element in the array.

int sum_matrix(int matrix1[10][10]);   // Legal
int sum_matrix(int matrix1[][10]);     // Legal
int sum_matrix(int matrix1[][]);       // Illegal

Question 9-1: The function in Example 9-9 should compute the length of a C-style string.^[1] Instead it insists that all strings are of length zero. Why?

/********************************************************
 * length -- compute the length of a string             *
 *                                                      *
 * Parameters                                           *
 *      string -- the string whose length we want       *
 *                                                      *
 * Returns                                              *
 *      the length of the string                        *
 ********************************************************/
int  length(char string[])
{
    int index;      // index into the string 

    /*
     * Loop until we reach the end of string character
     */
    for (index = 0; string[index] != ''; ++index)
        /* do nothing */
    return (index);
}

Let’s define a simple function to return the square of an integer:

int square(int value) {
    return (value * value);
}

We also want to square floating-point numbers:

float square(float value) {
    return (value * value);
}

Now we have two functions with the same name. Isn’t that illegal? In older languages, such as C and PASCAL, it would be. In C++ it’s not. C++ allows function overloading, which means you can define multiple functions with the same names. Thus you can define a square function for all types of things: int, float, short int, double, and even char, if we could figure out what it means to square a character.

To keep your code consistent, all functions that use the same name should perform the same basic function. For example, you could define the following two square functions:

// Square an integer
int square(int value);

// Draw a square on the screen
void square(int top, int bottom, int left, int right);

This is perfectly legal C++ code, but it is confusing to anyone who has to read the code.

There is one limitation to function overloading: C++ must be able to tell the functions apart. For example, the following is illegal:

int get_number(  );
float get_number(  );  // Illegal

The problem is that C++ uses the parameter list to tell the functions apart. But the parameter list of the two get_number routines is the same: ( ). The result is that C++ can’t tell these two routines apart and flags the second declaration as an error.

Suppose you want to define a function to draw a rectangle on the screen. This function also needs to be able to scale the rectangle as needed. The function definition is:

void draw(const int width, const int height, double scale)

After using this function for a while, you discover that 90% of the time you don’t use the draw’s scale ability. In other words, 90% of the time the scale factor is 1.0.

C++ allows you to specify a default value for scale. The statement:

void draw(const int width, const int height, double scale = 1.0)

tells C++, “If scale is not specified, make it 1.0.” Thus the following are equivalent:

draw(3, 5, 1.0);    	// Explicity specify scale 	
draw(3, 5);         		// Let it default to 1.0

There are some style problems with default arguments. Study the following code:

draw(3, 5);

Can you tell whether the programmer intended for the scale to be 1.0 or just forgot to put it in? Although sometimes useful, the default argument trick should be used sparingly.

If you define a parameter and fail to use it, most good compilers will generate a warning. For example, consider the following code:

void exit_button(Widget& button) {
    std::cout << "Shutting down
";
    exit (0);
}

This example generates the message:

Warning: line 1.  Unused parameter "button"

But what about the times you really don’t want to use a parameter? Is there a way to get C++ to shut up and not bother you? There is. The trick is to leave out the name of the parameter:

// No warning, but style needs work 
void exit_button(Widget&) {
    std::cout << "Shutting down
";
    exit (0); 	
}

This is nice for C++, but not so nice for the programmer who has to read your code. We can see that exit_button takes a Widget& parameter, but what is the name of the parameter? A solution to this problem is to reissue the parameter name as a comment:

// Better 	
void exit_button(Widget& /*button*/) { 
    std::cout << "Shutting down
"; 	    
    exit (0); 
}

Some people consider this style ugly and confusing. They’re right that it’s not that easy to read. There ought to be a better way; I just wish I could think of one.

One question you might be asking by now is, “Why would I ever write code like this? Why not just leave the parameter out?”

It turns out that many programming systems make use of callback functions . For example, you can tell the X Window System, “When the EXIT button is pushed, call the function exit_button.” Your callback function may handle many buttons, so it’s important to know which button is pushed. So X supplies button as an argument to the function.

What happens if you know that button can only cause X to call exit_button? Well, X is still going to give it to you, you’re just going to ignore it. That’s why some functions have unused arguments.

Looking back at the square function for integers, we see that it is a very short function, just one line. Whenever C++ calls a function, there is some overhead generated. This includes putting the parameters on the stack, entering and leaving the function, and stack fix-up after the function returns.

For example, consider the following code:

int square(int value) {
    return (value * value);
}
int main(  ) {
    // .....
    x = square(x);

The code generates the following assembly code on a 68000 machine (paraphrased):

label "int square(int value)"
        link a6,#0              // Set up local variables

        // The next two lines do the work
        movel a6@(8),d1         // d1 = value
        mulsl a6@(8),d1         // d1 = value * d1

        movel d1,d0             // Put return value in d0
        unlk a6                 // Restore stack
        rts                     // Return(d0)

label "main"
//....
//      x = square(x)
//
        movel a6@(-4),sp@-      // Put the number x on the stack
        jbsr "void square(int value)" 
                                // Call the function

        addqw #4,sp             // Restore the stack
        movel d0,a6@(-4)        // Store return value in X
// ...

As you can see from this code, there are eight lines of overhead for two lines of work. C++ allows you to cut out that overhead through the use of an inline function. The inline keyword tells C++ that the function is very small. This means that it’s simpler and easier for the C++ compiler to put the entire body of the function in the code stream instead of generating a call to the function. For example:

inline int square(int value) {
    return (value * value);
}

Changing the square function to an inline function generates the following, much smaller, assembly code:

label "main"
// ...
//      x = square(x)
//
        movel d1,a6@(-4)        // d1 = x
        movel a6@(-4),d0        // d0 = x
        mulsl d0,d0             // d0 = (x * x)

        movel d0,a6@(-4)        // Store result

Expanding the function inline has eliminated the eight lines of overhead and results in much faster execution.

The inline specifier provides C++ a valuable hint it can use when generating code, telling the compiler that the code is extremely small and simple. Like register, the inline specifier is a hint. If the C++ compiler can’t generate a function inline, it will create it as an ordinary function.