> ### Appendix 1, Section 1
> C++ Programming Fundamentals

> WHEN I DECIDED TO TEACH COMPUTER SCIENCE 124 with Java rather than C++, it was with the knowledge that most students would still have to learn C++ eventually. This is because C++ is still the major programming language for professional programmers. In addition, it has a number of language features that Java lacks and that computer science students should be familiar with. However, it was my feeling that Java would be a superior language for an introductory course, and that in any case much of what could be covered in an introductory Java programming course would also apply to C++. After two years of teaching Java and teaching C++ to students who had studied Java as their first programming language, I think I can say that my experience has confirmed or even exceeded expectations. I might even go so far as to advise someone whose only goal is to learn C++ to start with Java.

> Before beginning, I should note that recently, after eight years of work, a new standard version of C++ has been released. This new version makes several important changes to the language. It also adds a large, standard collection of classes called the Standard Template Library. In this chapter, I am talking about the older version of C++. For example, I say below that C++ has no standard String class. However, in the new version, the Standard Template Library does provide such a class. (Of course, until everyone actually makes the switch to the new version, the C++ String class is still not really standardized.)

> But before discussing C++, let me mention some of the things that it does not have (even in the new version). First of all, there is no platform-independent GUI support in C++. A typical first course in C++ might not even mention windows, graphics, or events. In addition, standard C++ does not have built-in support for threads or asynchronous programming. Nor does it have a standard interface for network programming. Of course, classes can be written to provide these features in C++. But since they are not standardized, such classes tend to be platform-dependent so that what you learn about one type of computer doesn't automatically apply to other computers. They also tend to be more complicated than the versions available in Java. By using Java, I was able to include these important features of modern computing environments in a natural way.

> But enough propaganda about Java. The rest of this chapter is a very brief overview of C++.

> ### Program Structure

> The first thing to know about C++ is that you can write entire, complicated programs without ever using classes or objects. Whereas in Java everything, even a program's `main()` routine, must be contained inside classes, C++ allows free-standing subroutines and variable declarations. The `main()` routine, in particular, cannot be a member of a class.

> C++ variables and subroutines that are defined outside classes are similar to static variables and subroutines in Java. For example, they exist for the whole time that the program is running. In C++, such variables and routines are said to be global or to have global scope. They can be used "globally" inside any subroutine and even in methods that belong to classes.

> However, no variable, class, or subroutine can be use in a C++ program unless it has been declared earlier in the same file. (This is different from Java, which allows you to use a variable or subroutine that is not declared until later in the program; of course, Java even allows you to use classes that are defined in other files, and it will go off and search for them when necessary.) This might seem to require the entire program to be in one big file, with the `main()` routine at the end, but that is not the case. To avoid this, C++ uses header files. A header file contains declarations of variables, subroutines, and classes that are actually defined in other files. C++ distinguishes carefully between declarations and definitions. The declaration of a subroutine, for example, gives only its name, its return type, and its parameter list. The definition of a subroutine also includes the code that defines the routine. A subroutine or variable must be declared before it is used in a source code file, but its definition can come later or even in another file. A header file contains only the declaration, which gives enough information to the compiler for it to check whether the subroutine or variable is being used legally.

> There are many standard header files that declare useful subroutines and classes. For example, the header file `math.h` defines mathematical functions such as `sin(x)` and `sqrt(x)`. (By convention, the name of a header file ends with ".h".) Another standard header file, `iostream.h`, defines stream classes that can be used for doing input and output. To get access to the declarations in a header file, a program must include the header file. This is done with a `#include` statement at the beginning of the program. For example, a program that starts with the statements

>                   #include <math.h>
>                   #include <iostream.h>

> will be able to use the mathematical functions and the stream classes. The `#include` statement is very similar to the `import` statement in Java. For example, saying `#include <iostream.h<` in C++ is similar to saying `import java.io.*` in Java. It's often a chore just determining which header files your program needs.

> When you write a large program in C++ and you want to break it up into several pieces, you will generally have to write two files for each piece: one file that actually defines some subroutines and classes, plus a header file that declares the same subroutines and classes. Other files that need access to those subroutines and classes must `#include` the header file to get access to them.

> ### Types and Variables

> C++ has standard types named `short`, `int`, `long`, `float`, `double`, and `char` that are similar to Java's primitive types with the same name. In C++, however, the exact meaning of these types is not completely standardized. I can't tell you the range of legal values for `ints`, for example, because the legal range is different on different systems. There is no standard `byte` data type, but `char` really plays the same role, since a `char` in C++ is considered to be simply an 8-bit integer.

> C++ does not really have a standard `String` type that is equivalent to the `String` type in Java. C++ does have some support for strings, but they are more difficult to use and they require a knowledge of pointers and arrays. I'll discuss them in the next section. It is possible to write a `String` class in C++ that is very similar to Java's class, and most C++ programmers would probably have access to such a class by `#including` a `String.h` header file. However, you can't depend on this since it's not a standard part of the language.

> Most versions of C++ (including the new standard) use `bool` as the name of the boolean type, and the names `true` and `false` are used for the values of type `bool`. However, in C++, `true` and `false` are names for the integers 1 and 0. In fact, an integer can be used wherever a `bool` value is expected, such as in an `if` statement. Any non-zero integer is considered to be `true`, while zero is `false`. So, to test whether the integer `N` is non-zero, you could say "`if (N)`..."

> I should note that there is a lot more to say about types in C++, since C++ has several different ways to define new types. Like Java, C++ has class types and array types. But it also has things called pointer types, structs, enumerated types, and function types. The later three types of types, I won't even mention again.

> Variables are declared and initialized in C++ in much the same way as in Java. C++ has global variables (declared outside subroutines and classes), instance variables in classes (both static and non-static), and local variables (declared inside subroutines or methods). As in Java, local variables can be declared at any point in a routine, and are valid only for the block in which they are declared. One big difference is that in C++, a variable can actually contain an object, whereas in Java, a variable can only contain a reference to an object. I'll discuss this further in Section 3.

> ### Control Structures, Assignment Statements, and Expressions

> Fortunately, there is very little to say about control structures in C++. Except for a few minor details that you will probably never encounter in practice, they are the same as in Java. That is, C++ has `if` statements, `for` statements, `while` loops, `do` loops, and `switch` statements that work the same way as their counterparts in Java. Also, you can use `break` statements and `continue` statements in C++, just as in Java.

> The same goes for assignment statements and expressions. All the operators are the same: +, -, *, /, %, ++, &&, ||, =, +=, and so on. One difference, already noted above, is that the mathematical functions are not contained in a `Math` class. Thus, instead of saying `y = Math.sqrt(x)`, you would say simply `y = sqrt(x)` (On the other hand, if you want to use the `sqrt()` function in C++, you have to `#include` the header file `math.h` at the beginning of your program. Whereas the `Math` class is automatically imported into every Java program, the `math.h` header file is not automatically included in a C++ program.)

> ### Input and Output

> Like Java, C++ has a standard input stream and a standard output stream for doing console input/output. The C++ versions are actually much more well-developed than the Java versions, but the syntax for using them is a bit strange. The standard input stream is called `cin`, and the standard output stream is called `cout`. (The "c" in these names stands for "console.") To use these streams in a program, you must `#include` the header file `iostream.h`.

> The syntax for reading a value from the standard input stream into a variable named `x` is:

>                 cin >> x;

> (The double-arrow operation is meant to indicate the direction of flow of information.) Output is similar, except that the direction of the arrows is reversed. For example,

>                cout << x;

> will output the value of the variable `x` to the console, and

>               cout << "Hello World!\n";

> will output the message "Hello World!". The new line character, '\n', outputs a carriage return at the end of the message. You can string several output items into a single statement, like this:

>               cout << "The square root of " << x << " is " << sqrt(x);

> You can do the same thing with `cin`.

> The standard I/O streams are instances of general stream classes called `ostream` and `istream`, which are analogous to Java's `PrintStream` and to my `TextInputStream`, respectively.

> ### Subroutines

> Subroutine definitions look pretty much the same in C++ as in Java, except of course that they are not necessarily found inside classes. The access modifiers `public`, `private`, and `protected` cannot be used outside classes. The `static` modifier can be used both inside and outside classes, but outside a class, it has a completely different meaning than it does inside a class. (It means that the subroutine is for use only in the file in which it is defined. The word static is grossly overused in C++, with several very different meanings in different contexts.)

> Subroutine call statements and function invocations are also just about identical in Java and in C++.

> Every program must have exactly one `main()` subroutine, and just as in Java, the system runs the program by calling its `main()` routine. The exact form of the main routine is not entirely standardized, and often several forms are acceptable. In some cases, for example, the main routine has return type `void`, while in other cases, it has return type `int`. (The `int` that is returned by the main routine is sent back to the system -- which called that routine -- as a status code to indicate whether the program completed successfully or ended in error.) On a given system, either or both of these formats might be acceptable.

> ### Exception Handling

> Although exception handling is not really a " programming fundamental," I mention it in this section because it is another area in which Java and C++ are very similar. C++ uses `try`, `catch`, and `throw` in the same way as C++. However, C++ does not allow a `finally` clause in a `try` statement, and it does not have the large number of predefined exception classes that Java has. Since exception handling is a recent addition to C++, it is still not completely well-integrated into the language. Many of the standard subroutines, for example, were written before exception handing was introduced, and they use older, alternative ways to deal with errors.

[ Next Section | Appendix Index | Main Index ]