Programming: C++ Program Design Including Data Structures, Third Edition
Chapter 22: Standard Template Library (STL)
Objectives
In this chapter you will: Learn about the Standard Template Library (STL) Become familiar with the basic components of the STL: containers, iterators, and algorithms Explore how various containers are used to manipulate data in a program Discover the use of iterators Learn about various generic algorithms
Introduction (continued)
ANSI/ISO Standard C++ is equipped with a Standard Template Library (STL) The STL provides class templates to process lists, stacks, and queues This chapter discusses many important features of the STL and shows how to use its tools
Components of the STL
Components of the STL:
- Containers - Iterators - Algorithms
Containers and iterators are class templates Iterators are used to step through the elements of a container Algorithms are used to manipulate data
Container Types
Containers are used to manage objects of a given type Three categories:
- Sequence (sequential) containers - Associative containers - Container adapters
Sequence Containers
Every object has a specific position Three predefined sequence containers:
- vector - deque - list
Sequence Container: Vector
A vector container stores and manages its objects in a dynamic array To use a vector container in a program, the program must #include <vector> To define an object of type vector, we must specify the type of the object because the class vector is a class template. For example, the statement vector<int> intList;declares intList to be a vector and the component type to be int. The statement vector<string> stringList; declares stringList to be a vector container and the component type to be string.
The class vector contains several constructors, including the default constructor
Sequence Container: Vector (continued)
Basic vector operations
- Item insertion - Item deletion - Stepping through the elements
Vector elements can be accessed using the operations below:
The class vector also contains member functions that can be used to find the number of elements currently in the container, the maximum number of elements that can be inserted into a container, and so on.
The class vector also contains member functions that can be used to manipulate the data, as well as insert and delete items, in a vector container.
Declaring an Iterator to a Vector Container
Vector contains a typedef iterator For example, the statement vector<int>::iterator intVecIter; declares intVecIter to be an iterator into a vector container of type int
The expression ++intVecIter advances the iterator intVecIter to the next element in the container The expression *intVecIter returns the element at the current iterator position.
Container and Functions begin and end
Every container contains the member function begin and end
- begin returns the position of the first element - end returns the position of the last element
Both functions have no parameters
The statement in Line 1 declares intList to be a vector container and the element type is int. The statement in Line 2 declares intVecIter to be an iterator in a vector container whose element type is int. After the following statement executes:
intVecIter = intList.begin();
the iterator intVecIter points to the first element in the container intList. The following for loop outputs the elements of intList to the standard output device:
for (intVecIter = intList.begin(); intVecIter != intList.end(); ++intVecList) cout << *intVecList << " ";
Function copy: convenient way to output the elements of a container Can be used with any container type Allows you to copy the elements from one place to another
- Can output the elements of a vector - Can copy the elements of one vector into another
The prototype of the function template copy is
template <class inputIterator, class outputIterator> outputItr copy(inputIterator first1, inputIterator last, outputIterator first2);
The parameter first1 specifies the position from which to begin copying the elements; the parameter last specifies the end position. The parameter first2 specifies where to copy the elements. Therefore, the parameters first1 and last specify the source; parameter first2 specifies the destination. Note that the elements within the range first1...last-1 are copied. The definition of the function template copy is contained in the header file algorithm. Thus, to use the function copy, the program must include the statement
#include <algorithm>
The function copy works as follows. Consider the following statement: int intArray[] = {5, 6, 8, 3, 40, 36, 98, 29, 75}; This statement creates an array intArray of nine components. The statement: vector<int> vecList(9); creates an empty container of nine components of type vector and the element type int. Now consider the statement copy(intArray, intArray + 9, vecList.begin()); This statement copies the elements starting at the location intArray until intArray + 9 - 1 into the container vecList. After the previous statement executes, vecList = {5, 6, 8, 3, 40, 36, 98, 29, 75}
Consider the statement copy(intArray + 1, intArray + 9, intArray); Here first1 is intArray + 1 and last is intArray + 9. Also, first2 is intArray. After the preceding statement executes, intArray = {6, 8, 3, 40, 36, 98, 29, 75, 75} Clearly, the elements of the array intArray are shifted to the left by one position.
Now consider the statement copy(vecList.rbegin() + 2, vecList.rend(), vecList.rbegin()); Recall that the function rbegin (reverse begin) returns a pointer to the last element into a container; it is used to process the elements of a container in reverse. Therefore, vecList.rbegin() + 2 returns a pointer to the third-to-last element into the container vecList. Similarly, the function rend (reverse end) returns a pointer to the first element into a container. The previous statement shifts the elements of the container vecList to the right by two positions. After the previous statement executes, the container vecList is vecList = {5, 6, 5, 6, 8, 3, 40, 36, 98}
The ostream Iterator and the Function copy
One way to output the contents of a container is to use a for loop, along with begin (initialize) and end (loop limit) copy can output a container; an iterator of the type ostream specifies the destination When you create an iterator of the type ostream, specify the type of element that the iterator will output
ostream_iterator<int> screen(cout, " ");
This statement creates screen to be an ostream iterator with the element type int. The iterator screen has two arguments: the object cout and a space. The iterator screen is initialized using the object cout. When this iterator outputs elements, they are separated by a space. The statement
copy(intArray, intArray + 9, screen);
outputs the elements of intArray on the screen. The statement
copy(vecList.begin(), vecList.end(), screen);
outputs the elements of the container vecList on the screen.
The statement
copy(vecList.begin(), vecList.end(), screen);
is equivalent to the statement
copy(vecList.begin(), vecList.end(), ostream_iterator<int>(cout, " "));
The statement
copy(vecList.begin(), vecList.end(), stream_iterator<int>(cout, ", "));
outputs the elements of vecList with a comma and space between them.
Sequence Container: deque
deque stands for double ended queue Implemented as dynamic arrays Elements can be inserted at both ends A deque can expand in either direction Elements are also inserted in the middle
Sequence Container: list
Lists are implemented as doubly linked lists Every element in a list points to both its immediate predecessor and its immediate successor (except the first and last element) The list is not a random access data structure
Iterators
An iterator points to the elements of a container (sequence or associative) Iterators provide access to each element The most common operations on iterators are ++ (increment) and * (dereference)
Types of Iterators
Five types of iterators:
- Input iterators - Output iterators - Forward iterators - Bidirectional iterators - Random access iterators
Input Iterators
Input iterators, with read access, step forward element-by-element; consequently, they return the values element-by-element.
These iterators are provided for reading data from an input stream.
Output Iterators
Output iterators, with write access, step forward element-by-element
Output iterators are provided for writing data to an output stream
Forward Iterators
Forward iterators combine all of the functionality of input iterators and almost all of the functionality of output iterators
Bidirectional Iterators
Bidirectional iterators are forward iterators that can also iterate backward over the elements The operations defined for forward iterators apply to bidirectional iterators Use the decrement operator to step backward
Random Access Iterators
Random access iterators are bidirectional iterators that can randomly process the elements of a container Can be used with containers of the types vector, deque, string, as well as arrays Operations defined for bidirectional iterators apply to random access iterators
typedef iterator
Every container contains a typedef iterator The statement
vector<int>::iterator intVecIter;
declares intVecIter to be an iterator into a vector container of the type int
typedef const_iterator
With the help of an iterator into a container and the dereference operator, *, you can modify the elements of the container If the container is declared const, then we must prevent the iterator from modifying the elements Every container contains typedef const_iterator to handle these situations
Stream Iterators
istream_iterator
- Used to input data into a program from an input stream
ostream_iterator
- Used to output data from a program into an output stream
Associative Containers
Elements in associative container are automatically sorted according to some ordering criteria The predefined associative containers in the are:
- STL Sets - Multisets - Maps - Multimaps
Associative Containers: set and multiset
Associative containers set and multiset automatically sort their elements multiset allows duplicates, set does not The default sorting criterion is the relational operator <(less than); that is, the elements are arranged in ascending order
The name of the class defining the container set is set; the name of the class defining the container multiset is multiset. The name of the header file containing the definitions of the classes set and multiset, and the definitions of the functions to implement the various operations on these containers, is set. To use any of these containers, the program must include the following statement: #include <set>
If you want to use sort criteria other than the default, you must specify this option when the container is declared. For example, consider the following statements:
The statement in Line 1 declares intSet to be an empty set container, the element type is int, and the sort criterion is the default sort criterion. The statement in Line 2 declares otherIntSet to be an empty set container, the element type is int, and the sort criterion is greater-than. That is, the elements in the container otherIntSet will be arranged in descending order. The statements in Lines 3 and 4 have similar conventions.
Container Adapters
The STL provides containers to accommodate special situations called container adapters The three container adapters are:
- Stacks - Queues - Priority Queues
Container adapters do not support any type of iterator
Stack
The STL provides a stack class
Queue
The STL provides a queue class
Algorithms
Operations such as find, sort, and merge are common to all containers and are provided as generic algorithms STL algorithms can be classified as follows:
- Nonmodifying algorithms - Modifying algorithms - Numeric algorithms - Heap algorithms
Nonmodifying Algorithms
Nonmodifying algorithms do not modify the elements of the container
Numeric Algorithms
Numeric algorithms perform numeric calculations on the elements of a container Numeric algorithms:
- accumulate - inner_product - adjacent_difference - partial_sum
Heap Algorithms
Heap sort algorithm sorts array data The array containing the data is viewed as a binary tree Heap algorithms:
- make_heap - push_heap - pop_heap - sort_heap
Function Objects
To make the generic algorithms flexible, the STL usually provides two forms of an algorithm using the mechanism of function overloading. The first form of an algorithm uses the natural operation to accomplish this goal. In the second form, the user can specify criteria based on which algorithm processes the elements. For example, the algorithm adjacent_find searches the container and returns the position of the first two elements that are equal. In the second form of this algorithm, we can specify criteria (say, less than) to look for the first two elements, such that the second element is less than the first element.
A function object contains a function that can be treated as a function using the function call operator, (). In fact, a function object is a class template that overloads the function call operator, operator(). In addition to allowing you to create your own function objects, the STL provides arithmetic, relational, and logical function objects, which are described in Table 22-26. The STL's function objects are contained in the header file functional.
The STL relational function objects can also be applied to containers. The STL algorithm adjacent_find searches a container and returns the position in the container where the two elements are equal. This algorithm has a second form that allows the user to specify the comparison criteria. For example, consider the following vector, vecList: vecList = {2, 3, 4, 5, 1, 7, 8, 9}; The elements of vecList are supposed to be in ascending order.
To see if the elements are out of order, we can use the algorithm adjacent_find as follows: intItr = adjacent_find(vecList.begin(), vecList.end(), greater<int>()); where intItr is an iterator of the vector type. The function adjacent_find starts at the position vecList.begin()--that is, at the first element of vecList--and looks for the first set of consecutive elements such that the first element is greater than the second. The function returns a pointer to element 5, which is stored in intItr.
Predicates are special types of function objects that return Boolean values. There are two types of predicates--unary and binary. Unary predicates check a specific property for a single argument. Binary predicates check a specific property for a pair--that is, two arguments. Predicates are typically used to specify searching or sorting criteria. In the STL, a predicate must always return the same result for the same value. The functions that modify their internal states cannot be considered predicates.
Insert Iterators
The STL provides three iterators, called insert iterators, to insert the elements at the destination:
- back_inserter - front_inserter - inserter
back_inserter: This inserter uses the push_back operation of the container in place of the assignment operator. The argument to this iterator is the container itself. We can copy the elements of list into vList by using back_inserter as follows:
copy(list, list + 5, back_inserter(vList));
front_inserter: This inserter uses the push_front operation of the container in place of the assignment operator. The argument to this iterator is the container itself. Because the vector class does not support the push_front operation, this iterator cannot be used for the vector container.
inserter: This inserter uses the container's insert operation in place of the assignment operator. There are two arguments to this iterator: the first argument is the container itself; the second argument is an iterator to the container specifying the position at which the insertion should begin.
STL Algorithms
STL algorithms include documentation with the function prototypes The parameter types in...