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.