We'll briefly cover a miscellaneous topic, exception handling. Some functions on containers (and other functions, generally) from the C++ standard library "throw" exceptions in cases of invalid input.

For example, consider hypothetical RMEs for the [] operator and .at() functions on a std::vector<T>:

// REQUIRES: The vector is not empty.
// EFFECTS: Returns (by reference) the element at the given index.
T & operator[](size_t index);

// EFFECTS: Returns (by reference) the element at the given index,
// unless the index is out of bounds, in which casea std::out_of_range
// exception is thrown.
T & at(size_t index);

The [] operator uses a REQUIRES clause to specify that the vector must not be empty, otherwise undefined behavior may occur. On the other hand, the .at() function uses an EFFECTS clause to specify that it will deterministically throw a std::out_of_range exception if the index is out of bounds.

So what does "throwing an exception" mean? First, an exception is an object that represents an error that has occurred. When the function throws the exception, it does not return in the normal way or yield a result, but instead begins an alternate control flow path to seek out appropriate error handling code.

Error handling code is specifed with a try/catch construct. The try block contains the code that may throw an exception, and the catch block contains the code that will handle the exception if it is thrown. The catch block also specifies the type of exception it can handle. If an exception is thrown, but not caught, the program terminates with an error message.

Here's an example:

#include <iostream>
#include <vector>
#include <stdexcept>
int main() {
  std::vector<int> vec = {1, 2, 3};
  try {
    int value = vec.at(3); // 3 is out of bounds
  }
  catch (const std::out_of_range &e) {
    cout << "Error - index was out of bounds." << endl;
  }
}

This also works across function calls, so if an exception were to be thrown in a helper function, it could be caught by the caller (or the caller's caller, and so on…).

In project 4, you'll use the csvstream library to read CSV (Comma Separated Values) input files, and you'll catch an exception thrown by the library if the input file cannot be opened. The project spec links to an example of how to do this.

We'll return to exceptions near the end of the course and discuss them in more detail.

There are two fundamental approaches to data representation for containers. The first of these is to use a contiguous allocation (i.e. elements are stored in an underlying array). std::array and std::vector are sequential containers from the C++ standard library that use this approach.

The second fundamental approach to data representation for containers is to use a linked structure (i.e. elements are stored in nodes that point to each other). std::list and std::forward_list are sequential containers from the C++ standard library that use this approach.

The C++ standard library uses the concept of an iterator to indicate the position of an element in a list and to facilitate traversal through elements.

Note that traversal by iterator is analogous to traversal by pointer, which we've seen previously. (Although not all iterators are literally implemented as pointers.)

Iterator types are also used to specify the parameter or return types for many functions from the standard library.