Lecture notes for CS 503, Advanced Programming I

Advanced Programming I Lecture Notes

18 January 2007 • C++ Review

Outline

Pointers and Dynamic Storage.
Classes and Pointers.
Stream I-O.
Arrays

Pointers

Pointers are not your friends.
If T is a type, T * is the type pointer to T.
A T * value is used as the address of a value of type T.
- The programmer must make sure that's always true.

Pointers and Values

Understand clearly the difference between a pointer to a value and the value itself.
- Confusing or forgetting the difference leads to unending, intense pain.
- Draw pictures!

Pointer Operations

Pointer values can be generated, dereferenced, assigned, compared, and computed.
The address-of operator & generates pointer values.
- If v is a variable of type T, then the expression &v is a value of type T*.

Pointer Dereferencing

The follow (or dereference) operator * follows (or dereferences) a pointer value to return the associated value.
- The programmer must make sure the dereferenced pointer value points to a valid value.

Pointer Assignment

Pointer assignment is straightforward: both sides have to have type T *.
The consequences of pointer assignment, however, are not so straightforward.
- The value address on the left-hand side is lost, possibly leading to garbage.
- The value address on the right-hand side is copied, leading to shared or aliases access.
The programmer must make sure pointer assignment doesn't cause chaos.

Pointer Comparison

(In-)equality comparisons are straightforward, as long as you remember that the addresses are being compared, not the values addressed.
- "hello world" == "hello world" may or may not be true.
Ordering comparisons (<, >, <= and >=) determine the order between two pointers pointing into the same value sequence.

Pointer Arithmetic

A pointer may be added to an integer value.
- The integer value is scaled by the size of the value being pointed at.
Pointer addition is not closed:
The sum of a pointer and an integer may not be a valid pointer.
The programmer must make sure that pointer addition results in a valid pointer.

Pointer Subtraction

Two pointers of the same type may be subtracted from each other.
- Subtraction only makes sense if the two pointers are pointing into the same value sequence.
- The result is the number of values between the two pointers.
- The result is signed; for positive results subtract the smaller pointer from the larger.

Dynamic Storage

Dynamic storage is really not your friend.
- Make absolutely sure you need it.
Most C++ value storage is laid-out at compile time.
- This is compile-time (or statically) allocated storage.
Compile-time allocated storage can be difficult or wasteful to use at run-time.
- How many customers did your store have yesterday?

Dynamically-Allocated Storage

Dynamically- (or heap-) allocated storage helps deal with the problems caused by compile-time allocation.
The two dynamic-storage operators are new and delete.
The expression new T allocates a storage chunk big enough to hold a value of type T.
- The storage chunk may or may not be initialized.
- The result of new T has type T *.

Freeing Dynamic Storage

If the variable p contains a valid value of type T *, the expression delete p recovers the storage being pointed to by p.
- The value in p is not changed; but it's now invalid.
  - All pointers to the recovered storage are invalid.
- Any operation on an invalid pointer value is undefined.

Freeing Rules

Each dynamically-allocated storage chunk must be freed exactly once.
- Attempting to free an already freed storage chunk leads to chaos.
The programmer must make sure the value in p was returned by a new statement.
```
int * i = &j;
delete i;
```

Classes and Pointers

Pointers are old C; classes are new C++.
Pointers and classes can work well together.
- Unfortunately we won't be studying that.
Without care, pointers and classes can make your programming life a nightmare.
- That's what we'll be studying.

Garbage is Born

Where garbage comes from:

struct C {
  data * data_ptr;
  C() : data_ptr(new data) { }
  };

static void t(void) { C c; }

This code violates the fundamental rule of dynamic memory:
If you allocate it, you free it.

Class Destructor

The class destructor should free class-allocated storage.

struct C {
  data * data_ptr;
  C() : data_ptr(new data) { }
 ~C() { delete data_ptr; }
  };

static void t(void) { C c; }

Unintentional Sharing

By default, base-type values are bit-wise copied.
This replicates pointers, leading to un-intentional sharing and dangling pointers on destruction.

Unintentional Sharing Example

struct C {
  data * p;
  C() : p(new data) { }
 ~C() { delete p; }
  };

static void t(C & c) { C c2(c); }

In t(), c2.p is c.p.
- Changing *(c2.p) changes *(c.p).
- Deleting *(c2.p) deletes *(c.p).

Class Instance Copying

Class instance copying happens all the time.
- For example, non-reference class parameters.
```
void t(C c) { }
```
  The call t(c) makes a copy of c.

The Copy Constructor

Use the class copy constructor to handle dynamic memory copying.
The copy constructor prototype is
C::C(const C &).
- Don't forget the reference &.
The details depend on the memory being managed.

Copy Constructor Example

struct C {
  data * data_ptr;

  C() : data_ptr(new data) { }

  C(const C & c) 
    : data_ptr(data_clone(c.data_ptr)) {}

 ~C() { delete data_ptr; }
  };

static void t(C & c) { C local_c(c); }

Class Instance Assignment

Instance assignment is similar to instance copying.
The default assignment uses bit copying.
- This leads to unintended sharing, dangling pointers, and garbage.

Instance Assignment Example

struct C {
  data * p;
  C() : p(new data) { }
  C(const C & c) 
    : p(data_clone(c.p)) {}
 ~C() { delete p; }
  };

static void t(C & c) { C c2; c2 = c; }

Instance Assignment Problems

Given
```
static void t(C & c) { C c2; c2 = c; }
```
the contents of c.p replaces the contents of c2.p.
- The previous contents of c2.p is garbage.
- c2.p and c.p are sharing storage.

The Assignment Operator

Classes should define an assignment operator to manage memory during assignments.
Dynamic memory management is simple:
- Deallocate memory in the instance to the left of the =.
- Clone memory from the instance to the right of the =.

Assignment Operator Example

struct C {
  data * data_ptr;
  C() : data_ptr(new data) { }
  C(const C & c) : data_ptr(data_clone(c.data_ptr)) {}
 ~C() { delete data_ptr; }

  // Bad example.
  C & operator = (const C & c) {
    delete data_ptr;
    data_ptr = data_clone(c.data_ptr);
    return *this;
    }
  };

Refining Assignment

Assignment usually can share code with the copy constructor constructor and the destructor.
- All would call the same private member functions.
Two tricks to assignment:
1. Self assignment a = a, and
2. the assignment expression a = b = c.

The Self-Assignment Problem

a = a self-assignment does occur in code.
- Particularly with references and parameters.
- This is a source of nasty errors.

Self-Assignment Example

C & C::operator = (const C & rhs) {
  delete data_ptr;
  data_ptr = copy_data(rhs.data_ptr);
  return *this;
  }

What happens with a = a?
Deallocating in lhs also deallocates in rhs.
- For a = a, *this = rhs.
- Deleting data_ptr deletes rhs.data_ptr.

Detecting Self-Assignment

Make sure *this is different from rhs.

If *this and rhs are different, proceeds as normal.
If *this and rhs are the same, be careful.

C & C::operator = (const C & rhs) {
  if (this != &rhs) {
    delete data_ptr;
    data_ptr = copy_data(rhs.data_ptr);
    }
  return *this;
  }

Assignments as Expressions

A little-known C++ fun fact: an assignment is an expression.
- x = y = z = 0.0;
- An assignment's value is the rhs's value.
Assignment should support this.
- Programmers may expect this behavior.
- Good programmers don't disappoint their colleagues.

Assignment Expressions

The assignment prototype is
```
T & operator = (const T & rhs)
```
- The prototype can be different, but it usually shouldn't be.
```
T operator = (const T & rhs)
```
  makes a more expensive copy. (Another one!)

Assignment Return

The assignment return value is *this.
Here returning a value reference is efficient and safe.
- Normally returning a value reference is a red flag.

Assignment and Copying

What's the difference between assignment and copying?
- Assignment redefines, copying defines (or initializes).
Sometimes copying looks like assignment.
```
widget w1 = w2;

w1 = w2;
```

Assignment vs. Copying

Despite the syntax, declared variables are initialized; the target state is undefined - unintentional replication.
In assignment, the target is defined and is redefined; unintentional replication, dangling pointers, and garbage.
Assignment vs. copy - redefinition vs. initialization; the state of the target.

The Rule of Three

If a class implements a destructor, a copy constructor, or an assignment operator, then it needs to implement all three.
- Classes with pointer-type instance variables need them all.
This is known as the Rule of Three.

Stream I-O

Stream structure and types
Unformatted input and output
Stream states
Formatted input-output
Stream sources.

Stream Structure

A stream is a sequence of data elements.
- A stream may contain an arbitrary number of elements.

Stream Parts

A stream has
- Stream position
- Stream pointer
- Stream data elements
- The stream ends.
  - The end-of-stream (or eos) position.

Stream Types

Data can move into or out of a stream.
- Input streams move data out of a stream.
- Output streams move data into a stream.
- Input-output streams do both.
input <istream>

output <ostream>

both <iostream>

Stream Output Operations

The write operations.

ostream & put(char c)

ostream & write(
  const char * s, streamsize cnt)

ostream & flush()

Stream States

A stream operation can put a stream in one of four states:
- fail when a soft error occurred.
- bad when a hard error occurred.
- eof when the end-of-stream condition occurs.
- good when none of the other states occurred.

Stream Predicates

Streams have four predicates to test stream state.
- good(), fail(), bad(), and eof().
- fail() tests for the fail or bad states.
Stream state is sticky; once set, it stays set until clear()ed.
- This can be an annoying source of hard-to-find program errors.

The EOS Stream State

The end-of-stream state occurs when
1. the stream pointer's at the end-of-stream position, and
2. the end-of-stream position is read.
- Just moving the stream pointer to the end-of-stream position does not set the eof state.

EOS Example

Don't do this Do this

~~while cin.eof()~~ ~~cin >> x~~ // whatever
while true cin >> x if cin.eof() break // whatever

Remember: should you read the text before or after the test?

State Test Operators

The bang unary prefix operator ! tests a stream's fail or bad state.
- !cin is the same as cin.fail().
```
std::ofstream of(filename)
if (!of)
  // Can't open the file.
```
- ! does not test the stream's end-of-stream state.

Streams as Booleans

Streams convert to booleans.

while (std::cin >> i) {
  // whatever
  }

Stream conversion does not test the stream's end-of-stream state.

Implicit vs. Explicit Tests

Favor the state predicates over the test operators.
- Make your meaning clear.
- Test for more than just failure (eos in particular).
On the other hand, implicit tests are simpler and less cluttered.

Formatted I-O Operators

The binary stream extraction operator >> performs formatted input from a stream.
```
istream >> variable
```
The binary stream insertion operator << performs formatted output to a stream.
```
ostream << value
```

Cascaded Stream Operations

The value of the extraction or insertion expression is the stream being read or written.
- This allows cascaded operators.
```
istream >> x >> y

ostream << "y = " << y << "\n"
```

Make sure you get the precidence right.

std::cout << i << " cat" 
          << i != 1 ? "s" : "" << ".\n";

Data Type Formats

A value's format depends on the value's type.
- Integers have the format -?[0-9]+.
Space characters are not part of any value format.
- Initial space characters are skipped.
- Trailing space characters end the value.
- This is true for characters and strings too.

File Streams

A stream can be attached to many data sources, files for example.
Streams that attach to files are known as fstreams.
- A file istream is an ifstream.
- A file ostream is an ofstream.
- A file iostream is an fstream.
- Use the <fstream> header for them all.

Opening File Streams

fs.open(fname) associates file stream fs and the file with the name fname using the default modes.
- For ifstreams, the default mode is reading.
- For ofstreams, the default mode is writing.
- For fstreams, the default mode is reading and writing.
The .is_open() member predicate determines if a file-stream association exists.

Closing Streams

The .close() member function dis-associates a stream from a file.
- This is called in the destructor, but call it explicitly anyway.
- Recover resources early.
- Demonstrate you know what you're doing.

String Streams

A stream attached to a string is a string stream.
- An input string stream is an istringstream.
- An output string stream is an ostringstream.
- An input-output string stream is a stringstream.
- All are defined in <sstream>.

String Stream Operations

Thei istringstream constructor primes the stream with the string to use.
```
std::istringstream iss("hello");
```
The ss.str() member function returns the string associated with the string stream ss.
```
sdt::ostringstream oss;
oss << i << " " << j;
std::string s = oss.str();
```

Arrays

An array is a contiguous sequence of values of type T.
- An array is a homogeneous data structure.
An individual value in an array is known as an array element.
The number of elements in an array is the array size.
- Array size is a cruel joke in C++.

Array Operations

The array index operator [] provides access to array elements.
An n-element array has valid indices 0 through n - 1 inclusive at both ends.
The sizeof() operator on an array returns the total number of bytes in the array, not the number of elements.

Array Size

The size of an array is fixed; the amount of space allocated to an array doesn't change.
Array indexing is not fixed; any valid value of n is an acceptable index into an array.
It is entirely the programmer's responsibility to make sure that array indices fall within the size of the array.

Arrays and Pointers

Arrays and pointers are closely related.
- Given the declaration T a[3];, a is just a constant pointer to the first (zeroth) element.
The indexing operation a[expr] is just a shorthand for the expression *(a + expr).
- The indexing operator can be applied to any valid pointer.

Multidimensional Arrays

The array-pointer similarity is dangerous when used with multidimensional arrays.
An array of arrays is not the same thing as an array of pointers.

Points to Remember

Dynamic storage and pointers aren't your friends.
Embrace and internalize the Rule of Three.
Understand the end-of-stream condition.
- Do you read before or after the test?

This page last modified on 25 July 2006.
This work is covered by a
Creative Commons License.

input	`<istream>`
output	`<ostream>`
both	`<iostream>`