CPSC 427a: Object-Oriented Programming

Notes by Michael J. Fischer
Presented by Ewa Syta

Lecture 5
September 13, 2012

What eof means Detecting and properly handling end of file is one of the most confusing things in C++.

The I/O stream has status flags associated with it. The eof flag is turned on when the stream attempts to read beyond the end of the file.

The eof flag may or may not be on after the last byte of the file has been read and returned to the user.

When eof is turned on

Whether eof is on depends on whether the current input operation can complete without looking at the next byte.

• If it needs the lookahead to detect completion, then it will try to read beyond the end of the file and will turn on the eof bit.
• If it doesn’t need the lookahead, then the eof flag will remain off.

Reading an int

What happens depends on the kind of read request. Consider what happens with cin >> x, where x is an int.

1. Bytes are read one at a time until either there are no more to read or a non-whitespace byte is read. If the first happens, no data is read into x, and both the fail and the eof flags are turned on (and the good flag is turned off).
2. If step 1 ended by finding a non-whitespace byte, then the stream checks if it is a character that can begin an integer. The ones that can are +, -, 0, 1, …, 9. If it is not one of these, the fail flag is set, the eof flag is off, and nothing is stored into x.

Reading an int (cont.)

1. If an allowable number-starting character is found, then reading continues character by character until a character is found that can not be a part of the number currently being read.
   Reading then stops, the characters read so far are converted to an int and stored into x. The fail flag is off since a number was successfully read into x. The eof flag will be on iff the reading was stopped by attempting to read past the end of the file.

Examples

The following examples show the remaining bytes in the file, where ␣ represents any whitespace character such as space or newline.

1. File contents: ␣123.
   An attempt to read past the end of the file is made since otherwise one can’t know that the number is 123 is complete. good and fail are off and eof is on.
2. File contents: ␣␣123␣.
   eof will be off and the next byte to be read is the one following the 3 that stopped the reading. good is on and fail and eof are off.
3. File contents: ␣.
   No number is present. Step 1 reads and discards the whitespace and attempts to read beyond the end of file. good is off and fail and eof are on.

End of file and error handling

There is a fourth status flag also, bad.

I/O functions set status flags after each I/O operation. bad means there was a read or write error on the file I/O. fail means the data was not appropriate to the field, e.g., trying to read a non-numeric character into a numeric variable. eof means that the end of file has been reached. good means that the above three bits are all off.

The whole state can be read with one call to rdstate().

Status functions

Functions are also provided for testing useful combinations of status bits.

• good() returns true if the good bit is set.
• bad() returns true if the bad bit is set.
  This is not the same as !good().
• fail() returns true if the bad bit or the fail bit is set.
• eof() returns true if the eof bit is set.

As in C, correct end of file and error checking require paying close attention to detail of exactly when these state bits are turned on.

To continue after a bit has been set, must call clear() to clear it.

How to read all numbers in a file

Here’s a simple example for how to add up all the numbers from an open stream in.

Problem Set 2 Notes The problem set asks to implement the methods declared in the file Square.hpp

Talking points:

• Global constants.
• Private data members.
• Two different constructors, one with a default parameter.
• Two methods and one global function are inline. Which ones?
• Meaning of const when it follows the parameter list.
• Use of reference parameters (indicated by &).

Call by value

Like C, C++ passes explicit parameters by value.

• x and y are independent variables.
• y is created when f is called and destroyed when it returns.
• At the call, the value of x (=3) is used to initialize y.
• The assignment y=4; inside of f has no effect on x.

Call by pointer

Like C, pointer values (which I call reference values) are the things that can be stored in pointer variables.

Also like C, references values can be passed as arguments to functions having corresponding pointer parameters.

• p is created when g is called and destroyed when it returns.
• At the call, the value of &x, a reference value, is used to initialize p.
• The assignment (*p)=4; inside of g changes the value of x.

Call by reference

C++ has a new kind of parameter called a reference parameter.

• This does same thing as previous example; namely, the assignment p=4 changes the value of x.
• Within the body of g, p is a synonym for x.
• For example, &p and &x are identical reference values.

I/O uses reference parameters

• The first argument to << has type ostream&.
• cout << x << y; is same as (cout << x) << y;.
• << returns a reference to its first argument, so this is also the same as
     cout << x;
     cout << y;

How should one choose the parameter type?

Parameters are used for two main purposes:

• To send data to a function.
• To receive data from a function.

Sending data to a function: call by value For sending data to a function, call by value copies the data whereas call by pointer or reference copies only an address.

• If the data object is large, call by value is expensive of both time and space and should be avoided.
• If the data object is small (eg., an int or double), call by value is cheaper since it avoids the indirection of a reference.
• Call by value protects the caller’s data from being inadvertantly changed.

Sending data to a function: call by reference or pointer

Call by reference or pointer allows the caller’s data to be changed.

Use const to protect the caller’s data from inadvertane change.

Ex: int f( const int& x ) or int g( const int* xp ).

Prefer call by reference to call by pointer for input parameters.

Ex: f( 234 ) works but g( &234 ) does not.

Reason: 234 is not a variable and hence can not be the target of a pointer.

(The reason f( 234 ) does work is a bit subtle and will be explained later.)

Receiving data from a function

An output parameter is expected to be changed by the function.

Both call by reference and call by pointer work.

Call by reference is generally preferred since it avoids the need for the caller to place an ampersand in front of the output variable.

Declaration: int f( int& x ) or int g( int* xp ).

Call: f( result ) or g( &result ).

The implicit argument

Every call to a class member function has an implicit argument, which is the object written before the dot in the function call.

Increments ex.count by 3.

this

The implicit argument is passed by pointer.

In the call ex.advance(3), the implicit argument is ex, and a pointer to ex is passed to advance().

The implicit argument can be referenced directly from within a member function using the keyword this.

Within the definition of advance(), count and this->count are synonymous.