UMBC CMSC202, Computer Science II, Fall 1998, Sections 0101, 0102, 0103, 0104

27. Standard Template Library

Thursday December 10, 1998

Assigned Reading: 

Handouts (available on-line):

Topics Covered:

• We continue the discussion of the Standard Template Library (STL). We give an overview of the classes and operations supported by STL. The vector, deque and list template classes we discussed in the previous lecture are called sequence containers in STL terminology. There are other types of containers. For example, the set and map classes are associative containers. In an associative container, the order that items are inserted are not important. You use an associative container to link a particular key to a particular value (e.g., a student's record with the student's id number).

• STL iterators are also more complicated than the simple examples we have seen up to this point. In STL terminology, iterators are classified according to the operations they support. An iterator may be an input iterator, an output iterator, a forward Iterator, a bidirectional iterator or a random access Iterator. STL container classes can be distinguished by the type of iterators they support. For example, vector and deque support random access iterators, but a list only supports a bidirectional iterator. Again, learning STL amounts to plowing through a lot of documentation to figure out how these template classes can be used. As you progress in your career as a computer scientist, being able to read and understand documentation becomes more and more important.

• Besides the container classes, STL also supports algorithms that work with these classes (e.g., binary search and sorting). In the next example program we use the random_shuffle() algorithm to randomly arrange the words from the spelling dictionary that we have stored in a vector. random_shuffle(V.begin(), V.end()) ; Here we give the random_shuffle() function a pair of iterators to indicate the range of items in the vector V that we want to shuffle (rather than the vector V itself). This is the customary style of STL function calls. The sample run shows that the first 10 words in V are indeed rearranged. However, each time we run the program, we always get the same 10 words.

• In revised program, we use a different version of random_shuffle() which takes a third argument. This third argument provides random_shuffle() with a mechanism for generating random numbers: random_shuffle(V.begin(), V.end(), rand) ; It would appear that rand would be the address of a function that random_shuffle() can call to get a random number. However, rand is in fact an object from the class RandomFunction. In the RandomFunction class, we overload the () operator. Thus, the expression rand(N) actually invokes the RandomFunction () operator and is not technically a function call to a function called rand().

  STL often uses this mechanism, which they call function objects, for passing functions to STL algorithms instead of passing a function pointer. This mechanism provides greater flexibility than passing a function pointer. For example, in our RandomFunction class, the constructor sets the random seed using the system clock and makes sure that the seed is set only once using the static member seeded.

  The sample run shows that we now get a different sequence of 10 words each time we run the program.

• Next, we look at some simple examples of the STL set class. The set class is implemented by a balanced binary search tree. In the first example program we use a set of strings to store the names of the months. The sample run shows that the set class stores the keys in sorted order. In this case, iterating through the set gives us the names of the months in alphabetic order.

  Note that the find() member function of set returns an iterator that "points to" the item found. If the item is not in the set, the value of end() is returned:

  if (months.find("july") != months.end()) { ... This works because end() does not point to the last item of the set, it points past the last item of the set. (This is analogous to returning 10 as the index into an array with 10 items where the items in the array are indexed from 0 to 9.)

• In the second example program using the set class, we insert the items of one set into another set. The syntax for this is: months.insert(Months.begin(), Months.end()) ; // insert a range Implementations of the STL set class are suppose to guarantee that inserting a sorted range into a set is relatively fast. (See sample run.)

• The set class allows us to store only the key in the set. If we want to store the key and some associated data, we need to use the map class.

  • In the first program we store the number of days in each month in a map. Note the use of a string to index into the map (q.v. extra credit part of Project 4). When we dereference an iterator into a map object, we get a pair object. The pair has two data members first and second. In a map class, the first member is the key and the second member is the associated data. The sample run shows that the items in a map are sorted according to the key.

  • If we want to store the names of the month according to chronological ordering rather than alphabetical ordering, we can provide the map template with a comparison function object. This comparison object should have an overloaded () operator that takes two keys and returns true when the first key is strictly less than the second key. In the second program, we implement such a comparison function object using another map. The sample run shows that the items in a map are now sorted according to chronological order.

  • For faster insertion and find, we can use the hash_map STL class. The hash_map class is implemented using a hash table instead of a binary search tree. The third program and sample run shows that the items in the hash_map container are stored in no particular order (the position of each item is determined by a hash function).

  • One example of a good use of the hash_map class is our map from the second program that allows us to determine the chronological ordering of the months. The fourth program is such a revision of the second program. See sample run.

• Discussions about the computer science curriculum and what sort of classes you should take after CMSC 202.