1. . STL: C++ Standard Library

2. Main Ideas u General purpose: generic data structures & algorithms, templates u Flexibility: Allows for many combinations of algorithm-container u Simple & uniform interface: interface through templates (not inheritence) u Efficiency

3. Components u Containers: data structures vector, list, map, set, deque u Adaptors: high-level data structure stack, queue, priority_queue u Iterators: allow access into containers u Algorithms: base algorithms sort, copy, search, min, max, … u Streams: input/output u String

4. Example u Using STL objects to implement a simplified version of ex2 Data structures:  string – represent words  map > Associate a word with the array of words that appear after it

5. Quick Facts Vector  Implements an array of objects of type T  Allows random-access to array  Can grow on as needed basis Map  “Associative Array”: maps keys to values  Implemented as balanced binary tree

6. Markov-1.cpp

7. Extension u Same but using k-order Markov chain u Represents the probability of a word after a prefix of k words Data structures: u list - represent a list of objects See Markov-k.cpp

8. Containers u Holds copies of elements u Assumes Copy Ctor & operator = u The standard defines the interface, not the implementation u Two main classes  Sequential containers: list, vector,....  Associative containers: map, multimap, set...

9. Sequential Containers u Maintain a linear sequence of objects Types of operations u Access/inesertion/deletion of elements at the front/end of sequence u Random access to elements

10. Sequential Containers list - a linked list of objects  Efficient insertion/deletion in front/end/middle vector - an extendable sequence of objects  Efficient insertion/deletion at end  Random access deque – double-ended queue  Efficient insertion/deletion at front/end  Random access

11. Sequential Container Interface u size(), empty() u push_front(x), push_back(x) u front(), back() u pop_front(), pop_back() vector & deque u operator[](int index)

12. Associative Containers u Maintain a collection of keys u Requires order on keys (less-than operator) u Keys can be accessed based on their order (Typical) Implementation: u red-black binary trees u O(log n) time for access/insert/delete

13. Associative Containers Set u A set of unique keys Map u Associate a value to key (associative array) u Unique value of each key Multiset Multimap u Same, but allow multiple values

14. Associative Containers & Order u Associative containers use operator< as default order u We can control order by using our own comparison function u To understand this issue, we need to use function object

15. Function Objects A class that implements operator() Advantages: u Use the template mechanism (class versus function) u Enable accumulating information in the function object

16. Example template class less { public: bool operator()(T& lhs, T& rhs) { return lhs < rhs; } }; less cmp; // declare an object if( cmp(1,2) ) … if( less ()(1,2) ) … Creates temporary objects, and then call operator()

17. Function Object Bases u Base classes for the functions objects are defined in STL. u These provide standard names for the arguments and return types. template class less : public binary_function { … }

18. Function Object Bases template struct unary_function { typedef Arg argument_type; typedef Res return_type; }; template struct binary_function { typedef Arg first_argument_type; typedef Arg2 second_argument_type; typedef Res return_type; };

19. Using Comparators template > class set { … } … set s1; set > s2;// same type set s3; MyComp cmp; set s4(cmp); Creates a new MyComp object. Use given MyComp object.

20. STL Iterators u Iterators are allow to traverse sequences u Methods  operator*  operator++, and operator— u Different types of iterators - to support read, write and random access u Containers define their own iterator types u Changing the container can invalidate the iterator

21. Iterator Types u Output: write only and can write only once u Input: read many times each item u Forward supports both read and write u Bi-directional support also decrement u Random supports random access (just like C pointer)

22. Iterators & Containers Bidirectional iterators: u list, map, set Random access iterators: u vector, deque Input/output/forward iterators: u iostreams

23. Iterators and Containers T::iterator – iterator type for type T begin() – front of the container end() – element after last Container C … Container::iterator i for( i = C.begin(); i != C.end(); i++) // do something with *i

24. Iterators & Streams Can access iostreams through iterators: istream_iterator in(cin); istream_iterator endOfInput; ostream_iterator out(cout); while( in != endOfInput ) { string s = *in++; *out++ = s; *out++ = “ “; } see useStreamIterators.cpp

25. Sequence Adapters u Adapters of basic containers u Very easy, but limited interface stack  provides push, pop, top, size and empty queue  also provides back priority_queue u provides same interface as stack u uses a compare function object

26. Algorithms Overview u Sequence operations  Non modifying: for_each, find, count, search, mismatch, equal  Modifying: transform, copy, swap, replace, fill, generate, remove, unique, reverse, rotate, random_shuffle u Sorted sequences operations  sort, lower_bound, upper_bound, equal_range, binary_search, merge, includes, set_union, intersection, difference, symmetric_difference

27. Algorithms u Most STL algorithms works on sequences u Sequences are passed as two iterators:  beginning element  element one after last u Algorithms depend on iterator type not on container type pq sequence [p,q)

28. Copy template Out copy(In first, In last, Out res) { while (first != last) *res++ = *first++; return res; } See useCopy.cpp

29. Non-modifying Sequence Algorithms  In find(In first, In last, const T& val) find the first occurence of val in the sequence  In find_if(In first, In last, Pred p) find the first element satisfying p  I1 find_first_of(I1 f1, I2 l1, I2 f2, I2 l2) find the first match between two sequences.  I1 search( I1 f1, I1 l1, I2 f1, I2 l2 ) search for the sequence f2...l2 inside f1..l1

30. Sorted Sequence Algorithms  sort(In first, In last[, class cmp]) find the first occurence of val in the sequence  In lower_bound(In first, In last, T const & val[, class cmp]) find the first element not less than val  bool binary_search(In first, In last, T const & val[, class cmp]) check if val appears in the sequence  Out merge( I1 f1, I1 l1, I2 f1, I2 l2, Out out ) merge two sorted sequences and write the merged sequence onto the output iterator out