2 A first impression of C++

Before we continue with the `real' object-oriented approach to programming, we first introduce further extensions of C++.

cout, cin and cerr

In analogy to C, C++ defines standard input- and output streams which are opened when a program is executed. The streams are:

• cout, analogous to stdout,
• cin, analogous to stdin,
• cerr, analogous to stderr.

Syntactically these streams are not used with functions: instead, data are read from the streams or written to them using the operators << and >>. This is illustrated in the example below:

    #include <iostream.h>

    int main ()
    {
        int
            ival;
        char
            sval [30];

        cout << "Enter a number:" << '\n';
        cin >> ival;
        cout << "And now a string:" << '\n';
        cin >> sval;

        cout << "The number is: " << ival
             << "\nAnd the string is: " << sval
             << '\n';

        return (0);
    }            

This program reads a number and a string from the cin stream (usually the keyboard) and prints these data to cout. Concerning the streams and their usage we remark the following:

• The streams are declared in the header file iostream.h.
• The streams cout, cin and cerr are in fact `objects' of a given class (more on classes later) which processes the input and output of a program. Note that the terminology `object' means here: the set of data and functions which define the item in question.
• The stream cin reads data and copies the information to variables (e.g., ival in the above example) using the right-shift operator >>. We will describe later how operators in C++ can perform quite other actions than what they are defined to do by the language grammar, such as is the case here.
• The operators which manipulate cin, cout and cerr (which are >> and <<) also manipulate variables of different types. In the above example cout << ival stands for the printing of an integer value. The actions of the operators therefore depend on the type of supplied variables.

The streams cin, cout and cerr are not part of C++ grammar sec, as defined in the compiler which parses source files. The streams are part of the definitions in the header file iostream.h. This is comparable to the fact that functions as printf() are not part of the C grammar, but were originally written by people who considered such functions handy and collected them in a run-time library.

Whether a program uses the old-style functions like printf() and scanf() or whether it employs the new-style streams is a matter of taste. Both styles can even be mixed. A number of advantages and disadvantages is given below:

• Compared to the standard C functions printf() and scanf(), the usage of the operators << and >> with their respective streams is more type-safe. The format strings which are used with printf() and scanf() can define wrong format specifiers for their arguments, for which the compiler (usually) doesn't warn. In contrast, argument checking with cin, cout and cerr is performed by the compiler.
• The functions printf() and scanf(), and other functions which use format strings, in fact implement a mini-language which is interpreted at run-time. In contrast, the C++ compiler knows exactly which in- or output action to perform given which argument.
• The usage of the left-shift and right-shift operators in the context of the streams does illustrate the possibilities of C++, but in our opinion hardly improves the readability of programs (rather the opposite is true).

The keyword const

The keyword const very often occurs in C++ programs, even though it is also part of the C grammar.

This keyword is a modifier which states that the value of a variable or of an argument may not be modified. In the below example an attempt is made to change the value of a variable ival, which is not legal:

    int main ()
    {
        int const               // a constant int..
            ival = 3;           // initialized to 3

        ival = 4;               // assignment leads
                                // to an error message

        return (0);
    }

This example shows how ival may be initialized to a given value in its definition; attempts to change the value later (in an assignment) are not permitted.

Variables which are declared const can, in contrast to C, be used as the specification of the size of an array, as in the following example:

    int const
        size = 20;
    char
        buf [size];         // 20 chars big

A further usage of the keyword const is seen in the declaration of pointers, e.g., in pointer-arguments. In the declaration

    char const *buf;

buf is a pointer variable, which points to chars. Whatever is pointed to by buf may not be changed: the chars are declared as const. The pointer buf itself however may be changed. A statement as *buf = 'a' is therefore not allowed, while buf++ is.

In the declaration

    char *const buf;

buf itself is a const pointer which may not be changed. Whatever chars are pointed to by buf may be changed at will.

Finally, the declaration

    char const *const buf;

is also possible; here, neither the pointer nor what it points to may be changed.

The rule of thumb for the placement of the keyword const is the following: whatever occurs just prior to the keyword may not be changed.

References

Besides the normal declaration of variables, C++ allows `references' to be declared as synonyms for variables. A reference to a variable is like an alias; the variable name and the reference name can both be used in statements which affect the variable:

    int
        int_value;
    int
        &ref = int_value;

In the above example a variable int_value is defined. Subsequently a reference ref is defined, which due to its initialization addresses the same memory location which int_value occupies. In the definition of ref, the reference operator & indicates that ref is not itself an integer but a reference to one. The two statements

    int_value++;            // alternative 1
    ref++;                  // alternative 2

have the same effect, as expected. At some memory location an int value is increased by one --- whether that location is called int_value or ref does not matter.

References serve an important role in C++ as a means to pass arguments which can be modified (`variable arguments' in Pascal-terms). E.g., in standard C, a function which increases the value of its argument by five but which returns nothing (void), needs a pointer argument:

    void increase (int *valp)       // expects a pointer
    {                               // to an int
        *valp += 5;
    }

    int main ()
    {
        int
            x;

        increase (&x)               // the address of x is
        return (0);                 // passed as argument
    }

This construction can naturally also be used in C++ but the same effect can be achieved with a reference:

    void increase (int &valr)           // expects a reference
    {                                   // to an int
        valr += 5;
    }

    int main ()
    {
        int
            x;

        increase (x);                   // a reference to x is 
        return (0);                     // passed as argument
    }

The way in which C++ compilers implements references is by internally using pointers: in other words, references in C++ are just ordinary pointers -- as far as the compiler is concerned. However, the programmer does not need to know or to bother about levels of indirection. (Compare this to the Pascal way: an argument which is declared as var is in fact also a pointer, but the programmer needn't know.)

It can be argued whether code such as the above is clear: the statement increase (x) in the main() function suggests that not x itself but a copy is passed. Yet the value of x changes because of the way increase() is defined.

Our suggestions for the usage of references as arguments to functions are therefore the following:

At the end of this chapter we would like to illustrate the analogy between C and C++ as far as structs are concerned. In C it is not uncommon to define several functions to process a struct, which then require a pointer to the struct as one of their arguments. A fragment of an imaginary C header file is given below:

    /* definition of a struct PERSON_ */
    typedef struct
    {
        char
            name [80],
            address [80];
    } PERSON_;

    /* some functions to manipulate PERSON_ structs */

    /* initialize fields with a name and address */
    extern void initialize (PERSON_ *p, char const *nm,
        char const *adr);

    /* print information */
    extern void print (PERSON_ const *p);

    /* etc.. */

In C++, the declarations of the involved functions are placed inside the definition of the struct or class. The argument which denotes which struct is involved is no longer needed.

    class Person
    {
        public:
            void initialize (char const *nm, char const *adr);
            void print (void);
            // etc..
        private:
            char name [80], address [80];
    };

The struct argument is implicit in C++. A function call in C like

    PERSON_
        x;

    initialize (&x, "some name", "some address");

is in C++:

    Person
        x;

    x.initialize ("some name", "some address");