Session 5: Pointers and Arrays, Iterators

Introduction

• Pointers and arrays: vestiges of C that survive in C++ (Savitch 10.1; Stroustrup 5.1-3; Horstmann 9.7).

• Iterators: objects that provide sequential access to the elements of containers (Savitch 17.3 and 19.2; Stroustrup 19.2).

• The interface offered by STL iterators is based on an analogy with pointers and arrays.

• The STL provides a number of generic functions that operate on iterators. In the STL, these are called algorithms.

Pointers and arrays

• C's arrays, pointers and pointer arithmetic survive in C++.

• Arrays are mostly superseded by vectors.

• C/C++ pointers support arithmetic, but this is little used in C++.

• Many uses of pointers are superseded by references, but they still have their uses:
  • Subtype polymorphism.

  • Dynamically allocated objects (sessions 8 and 9).

  • Dynamic data structures.

  • Legacy interfaces.

Pointers in C and C++

• Pointer variables are declared with *

      int *ip;
  

  This does not initialize the pointer.

• The address of a piece of storage, obtained with &, is a pointer:

      int i;
      ip = &i;
  

• Pointers are dereferenced with *

      *ip = *ip + 3;
  

  In general, * and & are inverses.

Undefined pointers

• Pointers that are local variables are not initialized.

• The storage pointed to by a pointer may become undefined. There will be no warning from the compiler or runtime system:

      int *p;
      {
          int i = 5;
          p = &i;
      }       // i ceases to exist
      *p = 3; // undefined behaviour
  

It is the programmer's responsibility to ensure that the pointer points at something whenever it is dereferenced.

Null pointers

• The value 0 in pointer types is distinct from any address.

      int *ip = 0;
  

  cf. null in Java.

• Pointers that are global variables or members of objects are initialized to 0 by default.

• Pointers that are local variables are not initialized.

More pointers

The following declaration

    const int *p;

Means that things pointed to by p cannot be changed through p (but p itself can be changed.)

It is possible to have pointers to pointers:

    int i;
    int *p1 = &i;
    int **p2 = &p1;
    int ***p3 = &p2;

and these may be qualified with const in various ways.

Pointers to objects

Given a class

    class Point {
    public:
        int x, y;
        Point (int xx, int yy) : x(xx), y(yy) {}
    };

We can refer to fields as follows:

    Point my_point(2, 3);
    Point *p = &my_point;
    cout << (*p).x << '\n';

or equivalently as

    cout << p->x << '\n';

and similarly for member functions.

Arrays

We have already used vectors, but C++ also has arrays, which are fixed in size:

        int arr[40];
        for (int i = 0; i < 40; i++)
                arr[i] = arr[i] + 5;

Unlike Java, there is no check that the index is in bounds.

Advice: use vectors instead unless the collection has a definite, fixed size.

Pointers and arrays

When assigning or initializing from an array, a pointer to the first element is copied, not the array:

    int arr[40];
    int *p = arr;

Now *p is equivalent to arr[0], and indeed to *arr.

The following are all equivalent:

    arr[0] = arr[0] + 5;
    *p = *p + 5;
    *arr = *arr + 5;

Parameter passing

Parameter passing is a form of initialization, so an array

    int arr[40];

can be passed as a pointer parameter:

    void f(int *p) { ... }

A function that really takes a pointer to a single element looks the same. (This is less common in C++ than in C, which has no references.)

C-style strings

• In C, strings are stored in char arrays, with the end of the string marked by a '\0' character.

      char name[] = "Bill"; // array of 5 chars
      char *name2 = "Fred"; // pointer to 5 chars
  

• Often char * indicates a C-style string.

      int main(int argc, char **argv) {
  

• C++'s string type is much safer.

• In most situations C-style strings (including string constants) can be used where a string is expected, and will be automatically converted.

• If you need a C-style string for some legacy interface, use the method c_str() of string.

Pointer arithmetic

Suppose p has type T *, and points to the ith element of an array of Ts. Then

• p + k is a pointer to the i+kth element.
• ++p is equivalent to p = p+1
• p - k is a pointer to the i-kth element.
• -p is equivalent to p = p-1
• p[k] is equivalent to *(p+k)

Again there are no checks that anything is in bounds.

It is also possible to subtract two pointers, which should be pointers to the same array.

Looping over an array

Given an array of integers:

    int arr[40];

The following are equivalent:

• Using indices:

      for (int i = 0; i < 40; ++i)
          arr[i] = arr[i] + 5;
  

• Using pointers:

      int *end = arr + 40;
      for (int *p = arr; p != end; ++p)
          *p = *p + 5;
  

  Note: arr + 40 cannot be dereferenced.

Iterators

An iterator is an object that provides sequential access to the elements of a container.

• The Java interface is analogous to a linked list or a stream:

      public interface java.util.Iterator {
          boolean hasNext();
          Object next();
          void remove();  // not always supported
      }
  

  (Because Java does not support genericity, the result of next() must be cast to the required type.)

• Iterators in the C++ STL are analogous to pointers to arrays.

Iterators in the STL

Iterating over a list of strings:

    list<string> names;
    ...
    for (list<string>::iterator p = names.begin();
            p != names.end(); ++p)
        cout << *p << '\n';

Each sequence includes a type iterator for its iterators, and two iterators:

begin()

positioned at the start of the sequence, and

end()

positioned just past the end of the sequence.

Each iterator supports the operators ==, ++ and *.

A variation: typedefs

In C++ we can define new names for types using typedef:

    typedef int time;
    typedef char * cstr;
    typedef deque<string> phrase;
    typedef vector<vector<double> > matrix;

(We can also do this in C, but only outside functions.)

We can use a typedef to introduce an abbreviation for the iterator type:

    typedef list<string>::iterator iter;
    for (iter p = names.begin(); p != names.end(); ++p)
        cout << *p << '\n';

The analogy

C		STL
array	arr	container	c
pointer	p	iterator	p
start pointer	arr	start iterator	c.begin()
end pointer	arr + LENGTH	end iterator	c.end()
increment	++p		++p
dereference	*p		*p

Iterator is a concept

• Iterator is an STL concept, not a C++ class.

• All iterators support the same operations in the same way:
  • Switching representations is relatively easy.

  • Generic code can be written using these operations.

• Special kinds of iterators support more operations.

• Checking is done when generic code is instantiated.

Iterator concepts in the STL

Different containers have different kinds of iterator, belonging to a hierarchy of iterator concepts:

Input Iterator

supports ==, ++, (unary) * and ->

e.g. the iterator of slist (singly linked lists).

Bidirectional Iterator

supports all these as well as -

e.g. the iterator of list.

Random Access Iterator

supports all these as well as <, +, - and [], which should behave similarly to operations on pointers.

e.g. the iterator of vector or deque.

A generic function

template <typename Iterator, typename Elem>
int count(Iterator start,
          Iterator finish, const Elem & v) {
    int n = 0;
    for (Iterator p = start; p != finish; ++p)
        if (*p == v)
            n++;
    return n;
}

There several requirements here (checked at instantiation):

• Iterator must be an input iterator type, with element type Elem.

• The Elem type must support ==.

Using the generic count function

The count function is defined in <algorithm>.

Here is an example of its use:

    list<string> names;
    string s;
    ....
    int n = count(names.begin(), names.end(), s);
    cout << s << " occurs " << n << " times\n";

In the above use,

• Iterator is list<string>::iterator

• Item is string.

Iterating over associative containers

• A map associates keys with values.

• The iterator of a map produces pairs of key and value.

• If p is an iterator for map<K, V>, then *p has type pair<const K, V>.

Printing out a map:

    map<string, int> table;
    ...
    typedef map<string, int>::iterator Iter;
    for (Iter p = table.begin(); p != table.end(); ++p)
        cout << p->first << " -> " << p->second << '\n';

Summary

• Some features inherited from C:

  arrays

  mostly superseded by vectors.

  pointers

  most useful for dynamic binding and dynamic structures.

• Iterators provide sequential access to the elements of containers.

• STL iterators look like pointers (++, *, -> etc).

• Many generic functions use iterators.

• After the reading week: inheritance in C++. (Savitch 14, 15 and 16.3; Stroustrup 12; Horstmann 14) Genericity and inheritance.