CONTENTS

Chapter 2. SETTING OUT TO C++

In this chapter you learn

•  C++ Initiation
•  More About C++ Statements
•  More C++ Statements
•  Functions
•  Summary
•  Review Questions
•  Programming Exercises

When you construct a simple home, you begin with the foundation and the framework. If you don't have a solid structure from the beginning, you'll have trouble later filling in the details, such as windows, door frames, observatory domes, and parquet ballrooms. Similarly, when you learn a computer language, you should begin by learning the basic structure for a program. Only then can you move on to the details, such as loops and objects. This chapter gives you an overview of the essential structure of a C++ program and previews some topics—notably functions and classes—covered in much greater detail in later chapters. (The idea is to introduce at least some of the basic concepts gradually en route to the great awakenings that come later.)

C++ Initiation

Let's begin with a simple C++ program that displays a message. Listing 2.1 uses the C++ cout (pronounced cee-out) facility to produce character output. The source code includes several comments to the reader; these lines begin with //, and the compiler ignores them. C++ is case-sensitive; that is, it discriminates between uppercase characters and lowercase characters. This means you must be careful to use the same case as in the examples. For example, this program uses cout. If you substitute Cout or COUT, the compiler rejects your offering and accuses you of using unknown identifiers. (The compiler also is spelling-sensitive, so don't try kout or coot, either.) The cpp filename extension is a common way to indicate a C++ program; you might need to use a different extension, as described in Chapter 1, "Getting Started."

Listing 2.1 myfirst.cpp

// myfirst.cpp--displays a message

#include <iostream>                           // a PREPROCESSOR directive
using namespace std;                          // make definitions visible
int main()                                    // function heading
{                                             // start of function body
    cout << "Come up and C++ me some time.";  // message
    cout << "\n";                             // start a new line
    return 0;                                 // terminate main()
}                                             // end of function body

#include <iostream>    // the way of the future
using namespace std;   // ditto

with

#include <iostream.h>  // in case the future has not yet arrived

cin.get();

After you use your editor of choice to copy this program (or else use the source code files from the Sams Publishing Web site at www.samspublishing.com), use your C++ compiler to create the executable code, as Chapter 1 outlined. Here is the output from running the compiled program:

Come up and C++ me some time.

You construct C++ programs from building blocks called functions. Typically, you organize a program into major tasks, and then design separate functions to handle those tasks. The example shown in Listing 2.1 is simple enough to consist of a single function named main(). The myfirst.cpp example has the following elements:

• Comments, indicated by the // prefix

• A preprocessor #include directive

• A using namespace directive

• A function heading: int main()

• A function body, delimited by { and }

• A statement that uses the C++ cout facility to display a message

• A return statement to terminate the main() function

Let's look at these various elements in greater detail now. The main() function is a good place to start because some of the features that precede main(), such as the preprocessor directive, are simpler to understand after you see what main() does.

The main() Function

Stripped of the trimmings, the sample program shown in Listing 2.1 has the following fundamental structure:

int main()
{
    statements
    return 0;
}

These lines state that you have a function called main(), and they describe how the function behaves. Together they constitute a function definition. This definition has two parts: the first line, int main(), which is called the function heading, and the portion enclosed in braces ({ and }), which is the function body. Figure 2.1 shows the main() function. The function heading is a capsule summary of the function's interface with the rest of the program, and the function body represents your instructions to the computer about what the function should do. In C++ each complete instruction is called a statement. You must terminate each statement with a semicolon, so don't omit the semicolons when you type the examples.

The final statement in main(), called a return statement, terminates the function. You learn more about the return statement as you read through this chapter.

The Function Heading as an Interface

Right now the main point to remember is that C++ syntax requires you to begin the definition of the main() function with this heading: int main(). This chapter discusses the function heading syntax in more detail later when it covers functions in general, but, for those who can't put their curiosity on hold, here's a preview.

In general, a C++ function is activated, or called, by another function, and the function heading describes the interface between a function and the function that calls it. The part preceding the function name is called the function return type; it describes information flow from a function back to the function that calls it. The part within the parentheses following the function name is called the argument list or parameter list; it describes information flow from the calling function to the called function. This general format is a bit confusing when you apply it to main(), because you normally don't call main() from other parts of your program. Typically, however, main() is called by startup code that your compiler adds to your program to mediate between the program and the operating system (UNIX, Windows XP, or whatever). In effect, the function header describes the interface between main() and the operating system.

Consider the interface for main(), beginning with the int part. A C++ function called by another function can return a value to the activating (calling) function. That value is called a return value. In this case, main() can return an integer value, as indicated by the keyword int. Next, note the empty parentheses. In general, one C++ function can pass information to another function when it calls that function. The portion of the function heading enclosed in parentheses describes that information. In this case, the empty parentheses mean that the main() function takes no information, or, in the usual terminology, main() takes no arguments. (To say that main() takes no arguments doesn't mean that main() is an unreasonable, authoritarian function. Instead, argument is the term computer buffs use to refer to information passed from one function to another.)

In short, the heading

int main()

states that the main() function can return an integer value to the function that calls it and that main() takes no information from the function that calls it.

Many existing programs use the classic C heading instead:

main()     // original C style

Under C, omitting the return type is the same as saying that the function is type int. However, C++ is phasing this usage out.

You also can use this variant:

int main(void)     // very explicit style

Using the keyword void in the parentheses is an explicit way of saying that the function takes no arguments. Under C++ (but not C), leaving the parentheses empty is the same as using void in the parentheses. (In C, leaving the parentheses empty means you are remaining silent about whether or not there are arguments.)

Some programmers use this heading and omit the return statement:

void main()

This is logically consistent, because a void return type means the function doesn't return a value. This variant works on many systems, but, because it isn't mandated as an option under current standards, it does not work on some systems.

Finally, the ANSI/ISO C++ Standard states that a

return 0;

statement implicitly is understood to come at the end of the main() function (but of no other function) if you don't explicitly provide it.

Why main() by Any Other Name Is Not the Same

There's an extremely compelling reason to name the function in the myfirst.cpp program main(): you must do so. Ordinarily, a C++ program requires a function called main(). (And not, by the way, Main() or MAIN() or mane(). Remember, case and spelling count.) Because the myfirst.cpp program has only one function, that function must bear the responsibility of being main(). When you run a C++ program, execution always begins at the beginning of the main() function. Therefore, if you don't have main(), you don't have a complete program, and the compiler points out that you haven't defined a main() function.

There are exceptions. For example, in Windows programming you can write a dynamic link library (dll) module. This is code that other Windows programs can use. Because a dll module is not a standalone program, it doesn't need a main(). Programs for specialized environments, such as for a controller chip in a robot, might not need a main(). But your ordinary standalone program does need a main(); this books discusses that sort of program.

C++ Comments

The double slash (//) introduces a C++ comment. A comment is a remark from the programmer to the reader that usually identifies a section of a program or explains some aspect of the code. The compiler ignores comments. After all, it knows C++ at least as well as you do, and, in any case, it's incapable of understanding comments. As far as the compiler is concerned, Listing 2.1 looks as if it were written without comments:

#include <iostream>
using namespace std;
int main()
{
    cout << "Come up and C++ me some time.";
    cout << "\n";
    return 0;
}

C++ comments run from the // to the end of the line. A comment can be on its own line or it can be on the same line as code. Incidentally, note the first line in Listing 2.1:

// myfirst.cpp -- displays a message

In this book all programs begin with a comment that gives the filename for the source code and a brief program summary. As mentioned in Chapter 1, the filename extension for source code depends on your C++ system. Other systems might use myfirst.C or myfirst.cxx for names.

#include <iostream> /* a C-style comment */

The C++ Preprocessor and the iostream File

Here's the short version of what you need to know. If your program is to use the usual C++ input or output facilities, provide these two lines:

#include <iostream>
using namespace std;

If your compiler doesn't like these lines (for example, if it complains that it can't find the file iostream), try the following single line instead:

#include <iostream.h >    // compatible with older compilers

That's all you really must know to make your programs work, but now take a more in-depth look.

C++, like C, uses a preprocessor. This is a program that processes a source file before the main compilation takes place. (Some C++ implementations, as you might recall from Chapter 1, use a translator program to convert a C++ program to C. Although the translator also is a form of preprocessor, we're not discussing that preprocessor; instead, we're discussing the one that handles directives whose names begin with #.) You don't have to do anything special to invoke this preprocessor. It automatically operates when you compile the program.

The listing uses the #include directive:

#include <iostream>    // a PREPROCESSOR directive

This directive causes the preprocessor to add the contents of the iostream file to your program. This is a typical preprocessor action: adding or replacing text in the source code before it's compiled.

This raises the question of why you should add the contents of the iostream file to the program. The answer concerns communication between the program and the outside world. The io in iostream refers to input, which is information brought into the program, and to output, which is information sent out from the program. C++'s input/output scheme involves several definitions found in the iostream file. Your first program needs these definitions to use the cout facility to display a message. The #include directive causes the contents of the iostream file to be sent along with the contents of your file to the compiler. In essence, the contents of the iostream file replace the #include <iostream> line in the program. Your original file is not altered, but a composite file formed from your file and iostream goes on to the next stage of compilation.

Header Filenames

Files such as iostream are called include files (because they are included in other files) or header files (because they are included at the beginning of a file). C++ compilers come with many header files, each supporting a particular family of facilities. The C tradition has been to use the h extension with header files as a simple way to identify the type of file by its name. For example, a math.h header file supports various C math functions. Initially, C++ did the same. For example, the header file supporting input and output was named iostream.h. More recently, however, C++ usage has changed. Now the h extension is reserved for the old C header files (which C++ programs still can use), whereas C++ header files have no extension. There also are C header files that have been converted to C++ header files. These files have been renamed by dropping the h extension (making it a C++ style name) and prefixing the filename with a c (indicating that it comes from C). For example, the C++ version of math.h is the cmath header file. Sometimes the C and C++ versions of C header files are identical, whereas in other cases the new version might have a few changes. For purely C++ header files such as iostream, dropping the h is more than a cosmetic change, for the h-free header files also incorporate namespaces, the next topic in this summary. Table 2.1 summarizes the naming conventions for header files.

In view of the C tradition of using different file extensions to indicate different file types, it appears reasonable to have some special extension to indicate C++ header files. The ANSI/ISO committee felt so, too. The problem was agreeing on which extension to use, so eventually they agreed upon nothing.

Namespaces

If you use iostream instead of iostream.h, you should use the following namespace directive to make the definitions in iostream available to your program:

using namespace std;

This is called a using directive. The simplest thing to do is to accept this for now and worry about it later (for example, in Chapter 9, "Memory Models and Namespaces"). But so that you won't be left completely in the dark, here's an overview of what's happening.

Namespace support is a fairly new C++ feature designed to simplify the writing of programs that combine pre-existing code from several vendors. One potential problem is that you might use two prepackaged products that both have, say, a function called wanda(). If you then use the wanda() function, the compiler won't know which version you mean. The namespace facility lets a vendor package its wares in a unit called a namespace so that you can use the name of a namespace to indicate which vendor's product you want. So Microflop Industries could place its definitions in a namespace called Microflop. Then Microflop::wanda() would become the full name for its wanda() function. Similarly, Piscine::wanda() could denote Piscine Corporation's version of wanda(). Thus, your program now could use the namespaces to discriminate between various versions:

Microflop::wanda("go dancing?");       // use Microflop namespace version
Piscine::wanda("a fish named Desire"); // use Piscine namespace version

In this spirit, the classes, functions, and variables that are a standard component of C++ compilers now are placed in a namespace called std. This takes place in the h-free header files. This means, for example, that the cout variable used for output and defined in iostream is really called std::cout. However, most users don't feel like converting pre-namespace code, which uses iostream.h and cout, to namespace code, which uses iostream and std::cout, unless they can do this without a lot of hassle. This is where the using directive comes in. The following line means you can use names defined in the std namespace without using the std:: prefix:

using namespace std;

This using directive makes all the names in the std namespace available. Modern practice regards this as a bit lazy. The preferred approach is to make just those names you need available with something called a using declaration:

using std::cout;  // make cout available
using std::cin;   // make cin available

If you put these at the top of the file instead of

using namespace std;  // lazy approach, all names available

you can use cin and cout without attaching the std:: to them. But if you need to use other names from iostream, you'll have to add them to the using list individually. Because you have enough else to do while learning C++, this book will take the lazy approach. But you may want to experiment with these other techniques.

C++ Output with cout

Now look at how you display a message. The myfirst.cpp program uses the following C++ statement:

cout << "Come up and C++ me some time.";

The part enclosed within the double quotation marks is the message to print. In C++, any series of characters enclosed in double quotation marks is called a character string, presumably because it consists of several characters strung together into a larger unit. The << notation indicates that the statement is sending this string to cout; the symbols point the way the information flows. And what is cout? It's a predefined object that knows how to display a variety of things, including strings, numbers, and individual characters. (An object, as you might remember from Chapter 1, is a particular instance of a class, and a class defines how data is stored and used.)

Well, this is a bit awkward. You won't be in a position to learn about objects for several more chapters, yet here you have to use one. Actually, this reveals one of the strengths of objects. You don't have to know the innards of an object in order to use it. All you must know is its interface—that is, how to use it. The cout object has a simple interface. If string represents a string, do the following to display the string:

cout << string;

This is all you must know to display a string, but now take a look at how the C++ conceptual view represents the process. In this view, the output is a stream—that is, a series of characters flowing from the program. The cout object, whose properties are defined in the iostream file, represents that stream. The object properties for cout include an insertion operator (<<) that inserts the information on its right into the stream. So the statement (note the terminating semicolon)

cout << "Come up and C++ me some time.";

inserts the string "Come up and C++ me some time." into the output stream. Thus, rather than say that your program displays a message, you can say that it inserts a string into the output stream. Somehow, that sounds more impressive. (See Figure 2.2.)

If you're coming to C++ from C, you probably noticed that the insertion operator (<<) looks just like the bitwise left-shift operator (<<). This is an example of operator overloading, by which the same operator symbol can have different meanings. The compiler uses the context to figure out which meaning is intended. C itself has some operator overloading. For example, the & symbol represents both the address operator and the bitwise AND operator. The * symbol represents both multiplication and dereferencing a pointer. The important point here is not the exact function of these operators but that the same symbol can have more than one meaning, with the compiler determining the proper meaning from the context. (You do much the same when you determine the meaning of "shoot" in "shoot the breeze" versus "shoot the piano player.") C++ extends the operator overloading concept by letting you redefine operator meanings for the user-defined types called classes.

The Newline Character (\n)

Now examine an odd-looking notation that appears in the second output statement:

cout << "\n";

The \n is a special C++ (and C) notation representing an important concept dubbed the newline character. Although you type the newline character by using two characters (\ and n), these count as a single character. Note that you use the backslash (\), not the regular slash (/). If you display the newline character, the screen cursor moves to the beginning of the next line, and if you send the newline character to a printer, the print head moves to the beginning of the next line. The newline character earns its name.

Note that the cout facility does not move automatically to the next line when it prints a string, so the first cout statement in Listing 2.1 leaves the cursor positioned just after the period at the end of the output string. To move the cursor to the beginning of the next line, you must send a newline character to the output. Or, to practice C++ lingo, you must insert a newline character into the output stream.

You can use the newline character just like any ordinary character. Listing 2.1 uses it in a separate string, but the listing could have used it in the original string. That is, you can replace the original two output statements with the following:

cout << "Come up and C++ me some time.\n";

You even can place the newline character in the midst of a string. For example, consider the following statement:

cout << "I am a mighty stream\nof lucid\nclarity.\n";

Each newline character moves the cursor to the beginning of the next line, making the output as follows:

I am a mighty stream
of lucid
clarity.

By leaving out newlines, you can make successive cout statements print on the same line. For example, the statements

cout << "The Good, the";
cout << "Bad, ";
cout << "and the Ukulele\n";

produce the following output:

The Good, theBad, and the Ukulele

Note that the beginning of one string comes immediately after the end of the preceding string. If you want a space where two strings join, you must include it in one of the strings. (Remem ber that to try out these output examples, you have to place them in a complete program, with a main() function heading and opening and closing braces.)

C++ has another way to indicate a newline in output: the word endl:

cout << "What's next?" << endl;    // endl means start a new line

This term is defined in iostream. It's a bit easier for most to type than "\n", but you only can use it separately, not as part of a string. That is, the string "What's next?\n" includes a newline character, but "What's next?endl" is just a string ending in the four letters e, n, d, and l.

C++ Source Code Formatting

Some languages, such as FORTRAN, are line-oriented, with one statement to a line. For these languages, the carriage return serves to separate statements. In C++, however, the semicolon marks the end of each statement. This leaves C++ free to treat the carriage return in the same way as a space or a tab. That is, in C++ you normally can use a space where you would use a carriage return, and vice versa. This means you can spread a single statement over several lines or place several statements on one line. For example, you could reformat myfirst.cpp as follows:

#include <iostream>
   using
    namespace
         std;
     int
main
() { cout
           <<
 "Come up and C++ me some time.";
    cout << "\n"; return 0; }

This is visually ugly, but valid, code. You do have to observe some rules. In particular, in C and C++ you can't put a space, tab, or carriage return in the middle of an element such as a name, nor can you place a carriage return in the middle of a string.

int ma  in()     // INVALID -- space in name
re
turn 0; // INVALID -- carriage return in word
cout << "Behold the Beans
 of Beauty!"; // INVALID -- carriage return in string

The indivisible elements in a line of code are called tokens. (See Figure 2.3.) Generally, you must separate one token from the next by a space, tab, or carriage return, which collectively are termed white space. Some single characters, such as parentheses and commas, are tokens that need not be set off by white space.

return0;           // INVALID, must be return 0;
return(0);         // VALID, white space omitted
return (0);        // VALID, white space used
int main()         // VALID, white space omitted
int main ( )       // ALSO VALID, white space used

C++ Source Code Style

Although C++ gives you much formatting freedom, your programs will be easier to read if you follow a sensible style. Having valid but ugly code should leave you unsatisfied. Most programmers use the style of Listing 2.1, which observes these rules:

• One statement per line

• An opening and a closing brace for a function, each of which is on its own line

• Statements in a function indented from the braces

• No white space around the parentheses associated with a function name

The first three rules have the simple intent to keep the code clean and readable. The fourth helps to differentiate functions from some built-in C++ structures, such as loops, that also use parentheses. The book will alert you to other guidelines as they come up.

More About C++ Statements

A C++ program is a collection of functions, and each function is a collection of statements. C++ has several kinds of statements, so let's look at some of the possibilities. Listing 2.2 provides two new kinds of statements. First, a declaration statement creates a variable. Second, an assignment statement provides a value for that variable. Also, the program shows a new capability for cout.

Listing 2.2 fleas.cpp

// fleas.cpp -- display the value of a variable
#include <iostream>
using namespace std;
int main()
{
    int fleas;             // create an integer variable

    fleas = 38;            // give a value to the variable
    cout << "My cat has ";
    cout << fleas;         // display the value of fleas
    cout << " fleas.\n";
    return 0;
}

A blank line separates the declaration from the rest of the program. This practice is the usual C convention, but it's somewhat less common in C++. Here is the program output:

My cat has 38 fleas.

The next few pages examine this program.

Declaration Statements and Variables

Computers are precise, orderly machines. To store an item of information in a computer, you must identify both the storage location and how much memory storage space the information requires. One relatively painless way to do this in C++ is to use a declaration statement to indicate the type of storage and to provide a label for the location. For example, the program has this declaration statement (note the semicolon):

int fleas;

This statement declares that the program uses enough storage to hold what is called an int. The compiler takes care of the details of allocating and labeling memory for that task. C++ can handle several kinds, or types, of data, and the int is the most basic data type. It corresponds to an integer, a number with no fractional part. The C++ int type can be positive or negative, but the size range depends on the implementation. Chapter 3, "Dealing with Data," provides the details on int and the other basic types.

Besides giving the type, the declaration statement declares that henceforth the program will use the name fleas to identify the value stored at that location. We call fleas a variable because you can change its value. In C++ you must declare all variables. If you were to omit the declaration in fleas.cpp, the compiler would report an error when the program attempts to use fleas further on. (In fact, you might want to try omitting the declaration just to see how your compiler responds. Then, if you see that response in the future, you'll know to check for omitted declarations. )

CastleDark = 34
...
CastleDank = CastleDark + MoreGhosts
...
PRINT CastleDark

In general, then, a declaration indicates the type of data to be stored and the name the program will use for the data that's stored there. In this particular case, the program creates a variable called fleas in which it can store an integer. (See Figure 2.4.)

The declaration statement in the program is called a defining declaration statement, or definition, for short. This means that its presence causes the compiler to allocate memory space for the variable. In more complex situations, you also can have reference declarations. These tell the computer to use a variable that already has been defined elsewhere. In general, a declaration need not be a definition, but in this example it is.

If you're familiar with C or Pascal, you're already familiar with variable declarations. You also might have a modest surprise in store for you. In C and Pascal, all variable declarations normally come at the very beginning of a function or procedure. But C++ has no such restriction. Indeed, the usual C++ style is to declare a variable just before it is first used. That way, you don't have to rummage back through a program to see what the type is. You'll see an example of this later in the chapter. This style does have the disadvantage of not gathering all your variable names in one place; thus, you can't tell at a glance what variables a function uses. (The new C99 standard, incidentally, now makes the rules for C declarations much the same as for C++.)

The Assignment Statement

An assignment statement assigns a value to a storage location. For example, the statement

fleas = 38;

assigns the integer 38 to the location represented by the variable fleas. The = symbol is called the assignment operator. One unusual feature of C++ (and C) is that you can use the assignment operator serially. That is, the following is valid code:

int steinway;
int baldwin;
int yamaha;
yamaha = baldwin = steinway = 88;

The assignment works from right to left. First, 88 is assigned to steinway; then the value of steinway, which is now 88, is assigned to baldwin; then baldwin's value of 88 is assigned to yamaha. (C++ follows C's penchant for allowing weird-appearing code.)

New Trick for cout

Up to now, the examples have given cout strings to print. Listing 2.2 additionally gives cout a variable whose value is an integer:

cout << fleas;

The program doesn't print the word fleas; instead, it prints the integer value stored in fleas, which is 38. Actually, this is two tricks in one. First, cout replaces fleas with its current numeric value of 38. Second, it translates the value to the proper output characters.

As you see, cout works with both strings and integers. This might not seem particularly remarkable to you, but keep in mind that the integer 38 is something quite different from the string "38". The string holds the characters with which you write the number; that is, a 3 character and an 8 character. The program internally stores the code for the 3 character and the 8 character. To print the string, cout simply prints each character in the string. But the integer 38 is stored as a numeric value. Rather than store each digit separately, the computer stores 38 as a binary number. (Appendix A, "Number Bases," discusses this representation.) The main point here is that cout must translate a number in integer form into character form before it can print it. Furthermore, cout is smart enough to recognize that fleas is an integer requiring conversion.

Perhaps the contrast with old C will indicate how clever cout is. To print the string "38" and the integer 38 in C, you could use C's multipurpose output function printf():

printf("Printing a string: %s\n", "38");
printf("Printing an integer: %d\n", 38);

Without going into the intricacies of printf(), note that you must use special codes (%s and %d) to indicate whether you are going to print a string or an integer. And if you tell printf() to print a string but give it an integer by mistake, printf() is too unsophisticated to notice your mistake. It just goes ahead and displays garbage.

The intelligent way in which cout behaves stems from C++'s object-oriented features. In essence, the C++ insertion operator (<<) adjusts its behavior to fit the type of data that follows it. This is an example of operator overloading. In later chapters, when you take up function overloading and operator overloading, you learn how to implement such smart designs yourself.

More C++ Statements

Look at a couple more examples of statements. The program in Listing 2.3 expands on the preceding example by allowing you to enter a value while the program is running. To do so, it uses cin (pronounced cee-in), the input counterpart to cout. Also, the program shows yet another way to use that master of versatility, the cout object.

Listing 2.3 yourcat.cpp

// yourcat.cpp -- input and output
#include <iostream>
using namespace std;
int main()
{
    int fleas;

    cout << "How many fleas does your cat have?\n";
    cin >> fleas;               // C++ input
// next line concatenates output
    cout << "Well, that's " << fleas << " fleas too many!\n";

    return 0;
}

Here is a sample output:

How many fleas does your cat have?
112
Well, that's 112 fleas too many!

The program has two new features: using cin to read keyboard input and combining three output statements into one. Let's take a look.

Using cin

As the output demonstrates, the value typed from the keyboard (112) eventually is assigned to the variable fleas. Here is the statement that performs that wonder:

cin >> fleas;

Looking at this statement, you practically can see information flowing from cin into fleas. Naturally, there is a slightly more formal description of this process. Just as C++ considers output as a stream of characters flowing out of the program, it considers input as a stream of characters flowing into the program. The iostream file defines cin as an object that represents this stream. For output, the << operator inserts characters into the output stream. For input, cin uses the >> operator to extract characters from the input stream. Typically, you provide a variable to the right of the operator to receive the extracted information. (The symbols << and >> were chosen to suggest visually the direction that information flows.)

Like cout, cin is a smart object. It converts input, which is just a series of characters typed from the keyboard, into a form acceptable to the variable receiving the information. In this case, the program declared fleas to be an integer variable, so the input is converted to the numerical form the computer uses to store integers.

More cout

The second new feature of yourcat.cpp is combining three output statements into one. The iostream file defines the << operator so that you can combine (concatenate) output as follows:

cout << "Well, that's " << fleas << " fleas too many.\n";

This allows you to combine string output and integer output in a single statement. The resulting output is the same as what the following code produces:

cout << "Well, that's ";
cout << fleas;
cout << " fleas too many.\n";

While you're still in the mood for cout advice, you also can rewrite the concatenated version this way, spreading the single statement over three lines:

cout   << "Well, that's "
       << fleas
       << " fleas too many.\n";

That's because C++'s free format rules treat newlines and spaces between tokens interchangeably. This last technique is convenient when the line width cramps your style.

A Touch of Class

You've seen enough of cin and cout to justify your exposure to a little object lore. In particular, you learn some more about the notion of classes. Classes are one of the core concepts for object-oriented programming in C++.

A class is a data type the user defines. To define a class, you describe what sort of information it can represent and what sort of actions you can perform with that data. A class bears the same relationship to an object that a type does to a variable. That is, a class definition describes a data form and how it can be used, while an object is an entity created according to the data form specification. Or, in noncomputer terms, if a class is analogous to a category such as famous actors, then an object is analogous to a particular example of that category, such as Kermit the Frog. To extend the analogy, a class representation of actors would include definitions of possible actions relating to the class, such as Reading for a Part, Expressing Sorrow, Projecting Menace, Accepting an Award, and the like. If you've been exposed to different OOP terminology, it might help to know that the C++ class corresponds to what some languages term an object type, and the C++ object corresponds to an object instance or instance variable.

Now get a little more specific. Recall this declaration of a variable:

int fleas;

This creates a particular variable (fleas) that has the properties of the int type. That is, fleas can store an integer and can be used in particular ways—for addition and subtraction, for example. Now consider cout. It is an object created to have the properties of the ostream class. The ostream class definition (another inhabitant of the iostream file) describes the sort of data an ostream object represents and the operations you can perform with and to it, such as inserting a number or string into an output stream. Similarly, cin is an object created with the properties of the istream class, also defined in iostream.

You have learned that classes are user-defined types, but as a user you certainly didn't design the ostream and istream classes. Just as functions can come in function libraries, classes can come in class libraries. That's the case for the ostream and istream classes. Technically, they are not built in to the C++ language, but are examples of classes that happen to come with the language. The class definitions are laid out in the iostream file and are not built in to the compiler. You even can modify these class definitions if you like, although that's not a good idea. (More precisely, it is a truly dreadful idea.) The iostream family of classes and the related fstream (or file I/O) family are the only sets of class definitions that came with all early implementations of C++. However, the ANSI/ISO C++ committee added a few more class libraries to the standard. Also, most implementations provide additional class definitions as part of the package. Indeed, much of the current appeal of C++ is the existence of extensive and useful class libraries supporting UNIX, Macintosh, and Windows programming.

The class description specifies all the operations that can be performed on objects of that class. To perform such an allowed action on a particular object, you send a message to the object. For example, if you want the cout object to display a string, you send it a message that says, in effect, "Object! Display this!" C++ provides a couple of ways to send messages. One way, called using a class method, essentially is a function call like the ones you've seen. The other, which is the one used with cin and cout, is to redefine an operator. Thus the statement

cout << "I am not a crook."

uses the redefined << operator to send the "display message" to cout. In this case, the message comes with an argument, which is the string to be displayed. (See Figure 2.5.)

Functions

Because functions are the modules from which C++ programs are built and because they are essential to C++ OOP definitions, you should become thoroughly familiar with them. Because some aspects of functions are advanced topics, the main discussion of functions comes later, in Chapters 7, "Functions—C++'s Programming Modules," and 8, "Adventures in Functions." However, if you deal now with some basic characteristics of functions, you'll be more at ease and more practiced with functions later. The rest of this chapter introduces you to these function basics.

C++ functions come in two varieties: those with return values and those with none. You can find examples of each kind in the standard C++ library of functions, and you can create your own functions of each type. Let's look at a library function that has a return value, and then examine how you can write your own simple functions.

Using a Function with a Return Value

A function that has a return value produces a value that you can assign to a variable. For example, the standard C/C++ library includes a function called sqrt() that returns the square root of a number. Suppose you want to calculate the square root of 6.25 and assign it to a variable x. You could use the following statement in your program:

x = sqrt(6.25); // returns the value 2.5 and assigns it to x

The expression sqrt(6.25) invokes, or calls, the sqrt() function. The expression sqrt(6.25) is termed a function call, the invoked function is termed the called function, and the function containing the function call is termed the calling function. (See Figure 2.6.)

The value in the parentheses (6.25, in this example) is information sent to the function; it is said to be passed to the function. A value sent to a function this way is called an argument or parameter. (See Figure 2.7.) The sqrt() function calculates the answer to be 2.5 and sends that value back to the calling function; the value sent back is called the return value of the function. Think of the return value as what is substituted for the function call in the statement after the function finishes its job. Thus, this example assigns the return value to the variable x. In short, an argument is information sent to the function, and the return value is a value sent back from the function.

That's practically all there is to it, except that before it uses a function, the C++ compiler must know what kind of arguments the function uses and what kind of return value it has. That is, does the function return an integer? A character? A number with a decimal fraction? A guilty verdict? Or something else? If it lacks this information, the compiler won't know how to interpret the return value. The C++ way for conveying this information is by using a function prototype statement.

A function prototype does for functions what a variable declaration does for variables—it tells what types are involved. For example, the C++ library defines the sqrt() function to take a number with (potentially) a fractional part (like 6.25) as an argument and to return a number of the same type. Some languages refer to such numbers as real numbers, but the name C++ uses for this type is double. (You see more of double in Chapter 3.) The function prototype for sqrt() looks like this:

double sqrt(double);   // function prototype

The initial double means sqrt() returns a type double value. The double in the parentheses means sqrt() requires a double argument. So this prototype describes sqrt() exactly as used in the following code:

double x;        // declare x as a type double variable
x = sqrt(6.25);

By the way, the terminating semicolon in the prototype identifies it as a statement, and thus makes it a prototype instead of a function heading. If you omit the semicolon, the compiler interprets the line as a function heading and expects you to follow it with a function body that defines the function.

When you use sqrt() in a program, you also must provide the prototype. You can do this in either of two ways:

• You can type the function prototype into your source code file yourself.

• You can include the cmath (math.h on older systems) header file, which has the prototype in it.

The second way is better because the header file is even more likely than you to get the prototype right. Every function in the C++ library has a prototype in one or more header files. Just check the function description in your manual or with online help, if you have it, and the description tells you which header file to use. For example, the description of the sqrt() function should tell you to use the cmath header file. (Again, you might have to use the older math.h header file, which works for both C and C++ programs.)

Don't confuse the function prototype with the function definition. The prototype, as you've seen, only describes the function interface. That is, it describes the information sent to the function and the information sent back. The definition, however, includes the code for the function's workings—for example, the code for calculating the square root of a number. C and C++ divide these two features—prototype and definition—for library functions. The library files contain the compiled code for the functions, whereas the header files contain the prototypes.

You should place a function prototype ahead of where you first use the function. The usual practice is to place prototypes just before the definition of the main() function. Listing 2.4 demonstrates the use of the library function sqrt(); it provides a prototype by including the cmath file.

Listing 2.4 sqrt.cpp

// sqrt.cpp -- use a square root function
#include <iostream>
using namespace std;
#include <cmath>        // or math.h
int main()
{
    double cover;       // use double for real numbers

    cout << "How many square feet of sheets do you have?\n";
    cin >> cover;
    double side;        // create another variable
    side = sqrt(cover); // call function, assign return value
    cout << "You can cover a square with sides of " << side;
    cout << " feet\nwith your sheets.\n";
    return 0;
}

CC sqrt.C -lm

Here's a sample run:

How many square feet of sheets do you have?
123.21
You can cover a square with sides of 11.1 feet
with your sheets.

Because sqrt() works with type double values, the example makes the variables that type. Note that you declare a type double variable by using the same form, or syntax, as when you declare a type int variable:

type-name variable-name;

Type double allows the variables cover and side to hold values with decimal fractions, such as 123.21 and 1.1. As you see in Chapter 3, type double encompasses a much greater range of values than type int.

C++ does allow you to declare new variables anywhere in a program, so sqrt.cpp didn't declare side until just before using it. C++ also allows you to assign a value to a variable when you create it, so you also could have done this:

double side = sqrt(cover);

You return to this process, called initialization, in Chapter 3.

Note that cin knows how to convert information from the input stream to type double, and cout knows how to insert type double into the output stream. As noted before, these objects are smart.

Function Variations

Some functions require more than one item of information. These functions use multiple arguments separated by commas. For example, the math function pow() takes two arguments and returns a value equal to the first argument raised to the power given by the second argument. It has this prototype:

double pow(double, double);  // prototype of a function with two arguments

If, say, you wanted to find 5 to 8th power, you would use the function like this:

answer = pow(5.0, 8.0);      // function call with a list of arguments

Other functions take no arguments. For example, one of the C libraries (the one associated with the cstdlib or the stdlib.h header file) has a rand() function that has no arguments and that returns a random integer. Its prototype looks like this:

int rand(void);        // prototype of a function that takes no arguments

The keyword void explicitly indicates that the function takes no arguments. If you omit void and leave the parentheses empty, C++ interprets this as an implicit declaration that there are no arguments. You could use the function this way:

myGuess = rand();       // function call with no arguments

Note that, unlike some computer languages, you must use the parentheses in the function call even if there are no arguments.

There also are functions that have no return value. For example, suppose you wrote a function that displayed a number in dollar and cents format. You could send it an argument of, say, 23.5, and it would display $23.50 onscreen. Because this function sends a value to the screen instead of to the calling program, it doesn't return a value. You indicate this in the prototype by using the keyword void for the return type:

void bucks(double);  // prototype for function with no return value

Because it doesn't return a value, you can't use the function as part of an assignment statement or of some other expression. Instead, you have a pure function call statement:

bucks(1234.56);      // function call, no return value

Some languages reserve the term function for functions with return values and use the terms procedure or subroutine for those without return values, but C++, like C, uses the term function for both variations.

User-Defined Functions

The standard C library provides over 140 predefined functions. If one fits your needs, by all means use it. But often you have to write your own, particularly when you design classes. Anyway, it's a lot more fun to design your own functions, so now let's examine that process. You've already used several user-defined functions, and they all have been named main(). Every C++ program must have a main() function, which the user must define. Suppose you want to add a second user-defined function. Just as with a library function, you can call a user-defined function by using its name. And, as with a library function, you must provide a function prototype before using the function, which you typically do by placing the prototype above the main() definition. The new element is that you also must provide the source code for the new function. The simplest way is to place the code in the same file after the code for main(). Listing 2.5 illustrates these elements.

Listing 2.5 ourfunc.cpp

// ourfunc.cpp -- defining your own function
#include <iostream>
using namespace std;
void simon(int);    // function prototype for simon()
int main()
{
    simon(3);       // call the simon() function
    cout << "Pick an integer: ";
    int count;
    cin >> count;
    simon(count);   // call it again
    return 0;
}

void simon(int n)   // define the simon() function
{
    cout << "Simon says touch your toes " << n << " times.\n";
                    // void functions don't need return statements
}

The main() function calls the simon() function twice, once with an argument of 3 and once with a variable argument count. In between, the user enters an integer that's used to set the value of count. The example doesn't use a newline character in the cout prompting message. This results in the user input appearing on the same line as the prompt. Here is a sample run:

Simon says touch your toes 3 times.
Pick an integer: 512
Simon says touch your toes 512 times.

Function Form

The definition for the simon() function follows the same general form as the definition for main(). First, there is a function header. Then, enclosed in braces, comes the function body. You can generalize the form for a function definition as follows:

type functionname(argumentlist)
{
     statements
}

Note that the source code that defines simon() follows the closing brace of main(). Like C, and unlike Pascal, C++ does not allow you to embed one function definition inside another. Each function definition stands separately from all others; all functions are created equal. (See Figure 2.8.)

Function Headings

The simon() function has this heading:

void simon(int n)

The initial void means that simon() has no return value. So calling simon() doesn't produce a number that you can assign to a variable in main(). Thus, the first function call looks like this:

simon(3);            // ok for void functions

Because poor simon() lacks a return value, you can't use it this way:

simple = simon(3);   // not allowed for void functions

The int n within the parentheses means that you are expected to use simon() with a single argument of type int. The n is a new variable assigned the value passed during a function call. Thus, the function call

simon(3);

assigns the value 3 to the n variable defined in the simon() heading. When the cout statement in the function body uses n, it uses the value passed in the function call. That's why simon(3) displays a 3 in its output. The call to simon(count) in the sample run causes the function to display 512 because that's the value given to count. In short, the heading for simon() tells you that this function takes a single type int argument and that it doesn't have a return value.

Let's review main()'s function header:

int main()

The initial int means that main() returns an integer value. The empty parentheses (which, optionally, could contain void) means that main() has no arguments. Functions that have return values should use the keyword return to provide the return value and to terminate the function. That's why you've been using the following statement at the end of main():

return 0;

This is logically consistent: main() is supposed to return a type int value, and you have it return the integer 0. But, you might wonder, to what are you returning a value? After all, nowhere in any of your programs have you seen anything calling main():

squeeze = main();   // absent from our programs

The answer is that you can think of your computer's operating system (UNIX, say, or DOS) as calling your program. So main()'s return value is returned not to another part of the program but to the operating system. Many operating systems can use the program's return value. For example, UNIX shell scripts and DOS batch files can be designed to run programs and test their return values, usually called exit values. The normal convention is that an exit value of zero means the program ran successfully, whereas a nonzero value means there was a problem. Thus, you can design your C++ program to return a nonzero value if, say, it fails to open a file. You then can design a shell script or batch file to run that program and to take some alternative action if the program signals failure.

User-Defined Function with a Return Value

Let's go one step further and write a function that uses the return statement. The main() function already illustrates the plan for a function with a return value: Give the return type in the function heading and use return at the end of the function body. You can use this form to solve a weighty problem for those visiting the United Kingdom. In the U.K., many bathroom scales are calibrated in stone instead of in U.S. pounds or international kilograms. The word stone is both singular and plural in this context. (The English language does lack the internal consistency of, say, C++.) One stone is 14 pounds, and the program in Listing 2.6 uses a function to make this conversion.

Listing 2.6 convert.cpp

// convert.cpp -- converts stone to pounds
#include <iostream>
using namespace std;
int stonetolb(int);     // function prototype
int main()
{
    int stone;
    cout << "Enter the weight in stone: ";
    cin >> stone;
    int pounds = stonetolb(stone);
    cout << stone << " stone are ";
    cout << pounds << " pounds.\n";
    return 0;
}

int stonetolb(int sts)
{
     return 14 * sts;
}

Here's a sample run:

Enter the weight in stone: 14
14 stone are 196 pounds.

In main(), the program uses cin to provide a value for the integer variable stone. This value is passed to the stonetolb() function as an argument and is assigned to the variable sts in that function. stonetolb() then uses the return keyword to return the value of 14 * sts to main(). This illustrates that you aren't limited to following return with a simple number. Here, by using a more complex expression, you avoid the bother of having to create a new variable to which to assign the value before returning it. The program calculates the value of that expression (196 in this example) and returns the resulting value. If returning the value of an expression bothers you, you can take the longer route:

int stonetolb(int sts)
{
      int pounds = 14 * sts;
      return pounds;
}

Either version produces the same result, but the second version takes slightly longer to do so.

In general, you can use a function with a return value wherever you would use a simple constant of the same type. For example, stonetolb() returns a type int value. This means you can use the function in the following ways:

int aunt = stonetolb(20);
int aunts = aunt + stonetolb(10);
cout << "Ferdie weighs " << stonetolb(16) << " pounds.\n";

In each case, the program calculates the return value and then uses that number in these statements.

As these examples show, the function prototype describes the function interface—that is, how the function interacts with the rest of the program. The argument list shows what sort of information goes into the function, and the function type shows the type of value returned. Pro grammers sometimes describe functions as black boxes (a term from electronics) specified by the flow of information into and out of them. The function prototype perfectly portrays that point of view. (See Figure 2.9.)

The stonetolb() function is short and simple, yet it embodies a full range of functional features:

• It has a heading and a body.

• It accepts an argument.

• It returns a value.

• It requires a prototype.

Consider stonetolb() as a standard form for function design. You'll go further into functions in Chapters 7 and 8. In the meantime, the material in this chapter should give you a good feel for how functions work and how they fit into C++.

MyFunction( )
myfunction( )
myFunction( )
my_function( )
my_funct( )

Statement Summary

The following list is a summary of the several kinds of C++ statements you've learned and used in this chapter:

• A declaration statement announces the name and the type of a variable used in a function.

• An assignment statement uses the assignment operator (=) to assign a value to a variable.

• A message statement sends a message to an object, initiating some sort of action.

• A function call activates a function. When the called function terminates, the program returns to the statement in the calling function immediately following the function call.

• A function prototype declares the return type for a function along with the number and type of arguments the function expects.

• A return statement sends a value from a called function back to the calling function.

Summary

A C++ program consists of one or more modules called functions. Programs begin executing at the beginning of the function called main() (all lowercase), so you always should have a function by this name. A function, in turn, consists of a heading and a body. The function heading tells you what kind of return value, if any, the function produces and what sort of information it expects to be passed to it by arguments. The function body consists of a series of C++ statements enclosed in paired braces: {}.

C++ statement types include declaration statements, assignment statements, function call statements, object message statements, and return statements. The declaration statement announces the name of a variable and establishes the type of data it can hold. An assignment statement gives a value to a variable. A function call passes program control to the called function. When the function finishes, control returns to the statement in the calling function immediately following the function call. A message instructs an object to perform a particular action. A return statement is the mechanism by which a function returns a value to its calling function.

A class is a user-defined specification for a data type. This specification details how information is to be represented and also the operations that can be performed with the data. An object is an entity created according to a class prescription, just as a simple variable is an entity created according to a data type description.

C++ provides two predefined objects (cin and cout) for handling input and output. They are examples of the istream and ostream classes, which are defined in the iostream file. These classes view input and output as streams of characters. The insertion operator (<<), which is defined for the ostream class, lets you insert data into the output stream, and the extraction operator (>>), which is defined for the istream class, lets you extract information from the input stream. Both cin and cout are smart objects, capable of automatically converting information from one form to another according to the program context.

C++ can use the extensive set of C library functions. To use a library function, you should include the header file that provides the prototype for the function.

Now that you have an overall view of simple C++ programs, you can go on in the next chapters to fill in details and expand horizons.

Review Questions

You find the answers to these and subsequent review questions in Appendix J, "Answers to Review Questions."

#include <iostream>

using namespace std;

int froop(double t)

Programming Exercises

Three blind mice
Three blind mice
See how they run
See how they run

Please enter a Celsius value: 20
20 degrees Celsius is 68 degrees Fahrenheit.

Enter the number of light years: 4.2
4.2 light years are 265608 astronomical units.

CONTENTS