1. Standard Template Library
Jim Fawcett Summer 2017
Standard Template Library

2. Standard Template Library
Some Definitions
vector, string, deque, and list are standard sequence containers.
set, multiset, map, multimap, unordered_set, unordered_multiset, unordered_map and unordered_multimap are standard associative containers.
Iterators:
Input iterators are read only – each iterated element may be read only once.
Output iterators are write-only – each iterated element may be written only once.
Forward iterators can read or write an element repeatedly. They don’t support operator--() so they can only move forward.
Bidirectional iterators are like forward iterators except that they support moving in both directions with operator++() and operator--().
Random access iterators are bidirectional iterators that add the capability to do iterator arithmetic – that is they support *(it + n);
Any class that overloads the function call operator - operator() - is a functor class, and we refer to its instances as functors or function objects.
Standard Template Library

3. STL Supports Guaranteed Complexity for Container Operations
Vectors and Deques:
Insertion is a linear time operation.
Accessing a known location is constant time.
Searching an unsorted vector or deque is a linear time operation.
Searching a sorted vector or deque should be a logarithmic time operation ( use binary_search algorithm to ensure that it is).
Lists:
Insertion is a constant time operation.
Accessing a known location and searching, whether sorted or not, is linear time, with the exception of the end points, which can be accessed in constant time.
Sets and Maps:
Based on Red-Black binary tree.
Insertion and accessing are logarithmic time operations.
Searching should be a logarithmic time operation (use member function find, etc., to ensure that it is).
Standard Template Library

4. STL Supports Guaranteed Complexity for Container Operations
Unordered_set and Unordered_map
Based on hashtable
Lookup, insertion, and deletion are (nearly) constant time operations
They are hashed containers, so we get access to an element by computing a hash function on a key which maps to an address in the table. This is constant time. If there is more than one element that hashes to that address then we search a linked list rooted at that address (the elements on this list are referred to as a bucket).
So access is nearly constant time.
Standard Template Library

5. STL Header Files for Containers
Include
Container Type
Description
<array>
array<T>
Fixed array of elements
<deque>
deque<T>
Double ended queue, fast insert/remove from either end, indexable.
<list>
list<T>
Doubly-linked list, fast insert/erase at current location and either end, slow traversal
<map>
map<key, value>
mulitmap<key, value>
Associates values with sorted list of keys, fast insert/remove, fast access with index, fast binary search, is indexable with keys.
<queue>
queue<T>
priority_queue<T>
First in, first out queue, efficient push and pop.
Efficient removal of largest.
<set>
set<T>
multiset<T>
Set of sorted keys, fast find/insert/removal.
<stack>
stack<T>
Last in, first out stack.
<unordered_map>
unordered_map<K,V>
Unordered_multimap<K,V>
Unordered key/value collection, constant time lookup, insertion, removal.
<unordered_set>
unordered_set<V>
unordered_multiset<V>
Unordered collection of values, constant time lookup, insertion, removal.
<vector>
vector<T>
Slow insert, delete, except at the end, fast access with index. Slow find. Capacity grows as needed.
Standard Template Library

6. Standard Template Library
Other STL Header Files
Include
Types
Description
<algorithm>
Find, find_if, search, copy, fill, count, generate, min, sort, swap, transform, …
Applied to a container over an iterator range.
<functional>
Function, bind, divides, equal_to, greater, less, negate, minus, plus, …
Function objects passed to an algorithm to operate on elements of a container.
<iterator>
operator+, operator=, operator++, operator--, operator*, operator->, …
Defines current location, range of action on a container or stream.
<memory>
unique_ptr, shared_ptr, allocator, operator==, operator!=, operator=, operator delete, operator new, …
Provides smart pointer for managing resources on native heap, supports redefinition of allocation policy for containers.
<numeric>
Accumulate, product, partial sum, adjacent difference, …
Applied to a container over an iteration range.
<utility>
Pair, operator!=, operator<=, operator>=, operator>, …
Pair struct and global operators.
Standard Template Library

7. Standard Template Library
STL Iterators
Input iterator
Read only, move forward
Example: istream_iterator
Output iterator
Write only, move forward
Examples: ostream_iterator, inserter, front_inserter, back_inserter
Forward iterator
Read and write, move forward
Example: forward_list<T>::iterator
Bidirectional iterator
Read and write, move forward and backward
Examples: list<T>::iterator, map<K,V>::iterator
Random access iterator
Read and write, random access
Examples: vector<T>::iterator, deque<T>::iterator, C++ pointers
Standard Template Library

8. Standard Template Library
STL Functions
unary functions:
Function taking single template argument
Will be instantiated with container’s value_type // unary function template <typename T> void printElem(T val) { cout << “value is: “ << val << endl; } void main( ) { list< int > li; : // unary function used in algorithm for_each(li.begin(), li.end(), printElem); }
for_each calls printElem with values from list
Standard Template Library

9. Standard Template Library
STL Functions
predicate:
function taking a template type and returning bool // predicate template <class T> bool ispositive(T val) { return (val > 0); } void main( ) { list<int> li; : // return location of first positive value list<int>::iterator iterFound = find_if(li.begin(), li.end(), ispositive<int>); }
Standard Template Library

10. Standard Template Library
STL Function Objects
Function objects:
class with constructor and single member operator() template <class T> class myFunc { public: myFunc( /*arguments save needed state info */) { } T operator()(/* args for func obj */) { /* call some useful function with saved state info and args as its parameters */ } private: /* state info here */ }
Standard Template Library

11. Standard Template Library
std::function adapted from example in
#include <functional> #include <iostream> #include <string> #include <vector> void execute(const std::vector<std::function<void()>>& fs) { for (auto& f : fs) f(); } void plain_old_func() std::cout << "\n I'm a plain old function"; class functor public: void operator()() const std::cout << "\n I'm a functor"; };
int main() { std::vector<std::function<void()>> x; x.push_back(plain_old_func); functor functor_instance; x.push_back(functor_instance); x.push_back([]() std::cout << "\n Hi, I'm a lambda expression"; }); execute(x); std::cout << "\n\n"; }
Standard Template Library

12. Standard Template Library
std::bind adapted from example in
#include <functional> #include <iostream> #include <string> #include <vector> void execute(const std::vector<std::function<void()>>& fs) { for (auto& f : fs) f(); } void show_text(const std::string& t) std::cout << "\n Text: " << t; int main() std::vector<std::function<void()>> x; x.push_back(std::bind(show_text, "Bound function")); execute(x); std::cout << "\n\n";
Standard Template Library

13. Standard Template Library
STL Function Objects
Standard Template Library

14. Standard Template Library
Algorithms by Type
Standard Template Library

15. Algorithms by Type (continued)
Standard Template Library

16. Standard Template Library
End of Presentation
Standard Template Library