Computer Science and Software EngineeringUniversity of Wisconsin - Platteville
11.Standard Template Library
Yan ShiCS/SE 2630 Lecture Notes
What is STL? The Standard Template Library (STL) is a subset of
ISO/ANSI C++ standard library. It provides 3 kinds of facilities:
— containers— iterators— generic algorithms
Appendix E in the textbookVisual Studio Help Doc:http://msdn.microsoft.com/en-us/library/c191tb28(v=vs.110).aspx
STL Container Sequence containers: maintain the original ordering of inserted
elements— list, vector, deque
Associative containers: elements are inserted in a pre-defined order— map, set, …
Container adapters: simple variations of the sequence containers— queue, stack, priority_queue— they do NOT support iterators: cannot be used by STL algorithms!
Container classes are template classes— e.g. list<int>, stack<float>
STL Iterators STL iterators enable cycling through a container, one
item at a time— allow C++ programs to access items in a container without
knowing the internal structure of the container— each STL container class defines one or more iterator types:
list<int>::iterator iter;— similar as GetNext()operation— it simply represents the location of an item within the
container— a generalization of a pointer
*iter // item referred to by iter iter++ // move to the next item
Types of Iterators Input iterators:
— can only step forward; permit only fetching; used for istream Output iterators:
— can only step forward; permit only storing; used for ostream Forward iterators:
— permit both fetching and storing Bidirectional iterators
— can move both forward and backward Random access iterators
— allow direct (random) access to any item in a containerRandom access > Bidirectional > Forward > Input/Output
Behavior defines iterator: — anything that acts like an iterator is an iterator!— e.g., pointers to an array is an iterator.
Iterator OperationsOperations Input Output Forward Bidirecti
onalRandom Access
*r Y Y Y Yr++; ++r Y Y Y Y Yr--; --r Y Y
r == r2; r != r2 Y Y Y Y Y*r = value Y Y Y Y
r[i] Yr += i; r -= i; Yr + i; r – i; Y
r – r2 //# of items Yr < r2; r > r2 Yr <= r2; r >= r2 Y
Iterator OperationsOperations Input Output Forward Bidirecti
onalRandom Access
*r Y Y Y Yr++; ++r Y Y Y Y Yr--; --r Y Y
r == r2; r != r2 Y Y Y Y*r = value Y Y Y Y
r[i] Yr += i; r -= i; Yr + i; r – i; Y
r – r2 //# of items Yr < r2; r > r2 Yr <= r2; r >= r2 Y
STL Algorithms An STL algorithm is a template function that has iterators for its
parameter types.— generic because it is a template and works with iterators, not containers
vector<int> v;int myArray[100];…sort( v.begin(), v.end() );sort( &myArray[0], &myArray[100] );sort( myArray, myArray+100 ); // why 100?
sort algorithm:template <class RandomAccessIterator>void sort ( RandomAccessIterator first, RandomAccessIterator last);
— The range used is [first, last)
http://www.cplusplus.com/reference/algorithm/
Vector<T> Class Generalize the concept of an array
— index: 0 to #elements – 1— but growable!— implemented with a dynamic array— has random access iterator
#include<vector>using namesapce std;vector<int> nums(100); // array of 100 integers, initialized to 0
Operations:— operator[] does not do bound checking— at(index) access item; throws out_of_range exception— operator== returns true if two vectors are the same— size() # of elements in the vector— push_back(item) adds item to the end of the vector— pop_back() deletes the element at the end of the vector— front() returns a reference to the first element in the vector— back() returns a reference to the last element in the vector
http://msdn.microsoft.com/en-us/library/9xd04bzs(v=vs.110).aspx
Vector<T> Class Be aware: Modifying a container while iterating over it can
"invalidate" the iterator!
erase(iterator) : removes item at iterator position
insert(iterator, item): insert item before iterator
Both erase and insert invalidate all iterators beyond the insert/erase point— they result in reallocating the array
Vector<T> Class The following discussion is true in general to all containers:
a vector pointer?— need to delete the pointer if pointing at dynamically allocated vector
object a vector of pointers?
— need to manually delete all dynamically allocated objects those pointers are pointing at before the vector goes out of scope
const_iterator:— for iterators over a collection that cannot be changedvector<Person>::const_iterator iter;…(*iter).Print(); // it has to be a const function!// or // iter->Print();
Function Objects Apply an operation to each of the elements in the range of a containertemplate <class InputIterator, class Function> Function for_each (InputIterator first, InputIterator last, Function fn); Sort a range of element in a container in descending order:template <class RandomAccessIterator, class Compare> void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
Function object or functor: a class object that acts like a function which overloads the function call operator.class Double{public: int operator() ( int i ) { return 2*i; }};...Double f;int n = f(15); // n becomes 30
list<T> Class template for a doubly linked list
— has bidirectional iterator— cheap insertion/deletion, O(i) to access item i
Inserting into a list while iterating over it is safe. If iter is an iterator,
executing erase(iter) invalidates iter (and any iterator equal to iter)
Erasing other positions is fine; — if xs is a list: iterator y = x; x++; xs.erase(y);
invalidates y but not x The list member functions merge, reverse, unique, remove, and
remove_if have been optimized.
deque<T> Class double-ended queue: “First or Last In, First or Last Out” very similar as a vector:
— provides fast random access into sequences of varying length. Differences from a vector:
— provide fast insertion and deletion at both ends of the collection – O(1) by providing unused reserve on both ends vector is fast only at the back
— Memory allocation is not guaranteed to be contiguous. accessing items in a deque tends to be slower than in a vector accessing elements in a deque by offsetting a pointer to another element causes undefined
behavior. — Any insertion or deletion other than the ends invalidates all iterators to the deque.
How about the ends? check msdn for details.
When to use deque?— people wait in line. front gets served, end loses patience and leaves.
http://msdn.microsoft.com/en-us/library/22a9t119(v=vs.110).aspx
stack<T> Adaptor An adaptor does NOT directly implement the
structure; instead, it provides a new interface for an existing container.
By default, stack<T> “adapts” deque<T> : LIFO #include <stack> Operations:
— empty, pop, push, size, top— comparison ( <, >, <=, >=, ==, != ): lexicographical
the first pair of element that are unequal determines the comparison result
queue<T> Adaptor By default, queue<T> “adapts” deque<T>: FIFO #include <queue> Operations:
— empty, back, front, pop, push, size— comparison( <, >, <=, >=, ==, != )
priority_queue<T> Adapter
#include <queue> similar with queue:
— push() means enqueue— pop() means dequeue
different from queue:— reordering right after enqueue to ensure the “highest priority”
item is always at the front of the queue. Operations
— empty, pop, push, size, top Example:
— job queue on a Linux server
Priority Queue Implementation
Unsorted list— enqueue: insert at the end of the list O(1)— dequeue: search and fetch the highest priority item O(n)
Array based sorted list— enqueue: insert and keep the order O(n)— dequeue: fetch the last item O(1)
Sorted linked list— enqueue: insert and keep the order O(n)— dequeue: fetch the first item O(1)
Binary search tree— enqueue: insert and keep the order O(log2n)— dequeue: fetch the last item O(log2n)
string Class string is not part of STL, but is part of the standard
library. need to #include <string> besides the operations we have learned, string has
many other operations similar to STL containers:— begin, end, clear, front, back, at, insert, erase,
push_back, pop_back, ...
http://www.cplusplus.com/reference/string/string/
Associative Containers The associative containers can be grouped into two subsets: maps and
sets.
Map, aka dictionary, consists of a key/value pair:— key: used to order the sequence— value: associated with that key— map<T>, multimap<T> (allow multiple keys ) — not officially part of STL: hash_map<T>, hash_multimap<T> store
elements as a hash table to improve search time
Set: an ascending container of unique elements— set<T>, multiset<T> (allow multiple instances of an element)— not officially part of STL: hash_set<T>, hash_multiset<T>
set<T> Class an ascending container of unique elements
— < must be defined— O(log2 n) insertion, deletion— bidirectional iterator— implemented based on balanced binary search tree (like a
red-black tree): sorted— the only thing that invalidates an iterator is an erase on that
iterator: similar as list Operations:
— size, empty, begin, end, find, lower_bound, upper_bound— insert, erase
http://msdn.microsoft.com/en-us/library/e8wh7665(v=vs.110).aspx
Red-Black Tree A type of self-balancing binary search tree Rules for red-black trees (Data Structres and the STandard
Template Library, William J. Collins, McGraw-Hill, 2003)— all nodes are colored red or black— if an item is red, its parent must be black— the number of black items must be the same in all paths from
the root item to an item with no children or with one child Maximum height is less than 2 log2 n a red-black tree demo
multiset<T> Class used when more than one instances of an
element is possible— The value serves as the key— erase ( key_value ): returns the number
of elements erased— equal_range: returns a pair of iterator <
upper_bound, lower_bound>
map<T> Class Each element is a pair of key and value.
— Sorted: key is unique and used to sort the data.— Use bidirectional iterator.— implemented as balanced binary search tree— the only thing that invalidates an iterator is an erase on that
iterator: similar as list Operation
— begin, end, find, at, count, equal_range— insert, erase
multimap<T> is used when the key is not necessarily unique.
Choosing Containers The choice of container type should be based in general on the
type of searching and inserting required by the application. — Use vector to manage a sequence if:
random access to any element is at a premium insertions or deletions of elements are only required at the end of a
sequence.— Use deque if you want to use vector but also need to do
insertion/deletion at the front of a sequence.— Use list if need to do merge, reverse, unique, remove, and remove_if— Associative containers are optimized for the operations of lookup,
insertion and removal. O(log2N) insertion/deletion. Insertion doesn’t invalidate iterators; deletion only invalidates iterators
pointing to the elements to delete.