Generic Programming and the STL

1. Generic Programmingand the STL Andreas FabriGeometryFactory

2. 0.1 Function Templates float min(float a, float b) int min(int a, int b) template < class Comparable> Comparable min(Comparable a, Comparable b) { return (a<b) ? a : b; } BigInt n(9), m(8), r; r = min( n, m ); BigInt is a model for the concept Comparable Generic Programming and the STL

3. 0.2 Class Templates template < class T> class list { void push_back(const T& x); typedef ... iterator; iterator begin(); iterator end(); }; list<int> ints; list<Triangulation_2::Vertex_handle> vertex_handles; Generic Programming and the STL

4. 1 Standard Template Library (STL) • Part of ISO-OSI Standard C++ Library 1998 • Object oriented programming is about reuse • STL has many reusable components • Divided into • containers • iterators • algorithms Generic Programming and the STL

5. 1.1 Introduction to Containers • Three types of containers • sequence containers • associative containers • container adapters • Near-containers - similar to containers, without all the capabilities • C-like arrays • string • bitset for maintaining sets of 1/0 flag values • valarray - high-speed mathematical vector operations • The containers have similar functions Generic Programming and the STL

6. 1.1 Introduction to Containers (II) • vector direct access to any element • deque rapid insertion at front or back direct access to any element • list rapid insertion and deletion anywhere • set rapid lookup, no duplicates • multiset rapid lookup, duplicates • map, multimap store key/value pairs • stack last-in-first-out • queue first-in-first-out • priority_queue highest priority element is first Generic Programming and the STL

7. 1.1 Introduction to Containers (III) • Common member functions of all STL containers • constructors, destructors • assignment, all comparison operators • swap • empty • max_size • size • Use if(c.empty()) not if(c.size() == 0) Generic Programming and the STL

8. 1.2 Introduction to Iterators • Iterators are similar to pointers • point to element in a container • iterator operators uniform for all containers • * dereferences, ++ advances pointer • container.begin() returns iterator pointing to first element • container.end() returns iterator pointing after last element it for(it = c.begin(); it != c.end(); it++) { ... } Generic Programming and the STL

9. 1.2 Iterator Categories • All iterators: p++, ++p • Input iterators: v = *p, p1 = p2, p1 == p2, p1 != p2 • Output iterators: *p = v, p1 = p2 • Forward iterators: all above • Bidirectional iterators: p--, --p • Random access iterators: p+=i; p-=i, p+i, p-i, <,>,… Generic Programming and the STL

10. 1.2 Constness of Iterators • Examplesvector<int>::iterator it = v.begin();vector<int>::const_iterator cit = v.begin();*cit = 24; // does not compile *it = 24; // okvoid fct(const vector<int>& v) { vector<int>::iterator it; it = v.begin(); // does not compile} Generic Programming and the STL

11. 1.2 Iterator Adapters • Everything that behaves like an iterator is an iterator • Insert iterator • Stream iterator • Reverse iterators • Example:list<Point> L;copy(istream_iterator<Point>(cin), istream_iterator<Point(), back_inserter(L));list<Point>::reverse_iterator r1 = L.rbegin(), r2 = L.rend(); Generic Programming and the STL

12. 1.2 CGAL Circulators • Geometric structures are often circular • Leads to other loop:Circ c1 = vertex.incident_vertices();Circ done = c1;do { something(*c1); c1++;} while(c1 != done); Generic Programming and the STL

13. 1.3 Introduction to Algorithms • STL provides algorithms used generically across containers • operate on elements indirectly through iterators • often operate on sequences of elements defined by pairs of iterators • algorithms often return iterators, such as find() • premade algorithms save programmers time and effort Generic Programming and the STL

14. 2 Sequence Containers • Three sequence containers • vector - based on arrays • deque - based on arrays • list - robust linked list Generic Programming and the STL

15. 2.1 vector Sequence Container • vector • #include <vector> • data structure with contiguous memory locations • use the subscript operator [] • used when data must be sorted and easily accessible • when memory exhausted • allocates a larger, contiguous area of memory • copies itself there • deallocates the old memory • has a random access iterator Generic Programming and the STL

16. 2.1 vector Sequence Container • Declarations • vector <type> v; • vector <type> v(7812); • template <class It>vector<type> v(It begin, It end); • type- int, float, Point, whatsoever • Warning: Beware of vector<bool> • Iterators: • vector<type>::const_iterator it; vector<type>::iterator it = v.begin(); *(it1 + 5) = 34; Generic Programming and the STL

17. 2.1 vector Sequence Container (II) • vector functions, for vector object v v.push_back(value) - add element to end v.size() - current size of vector v.capacity() - how much vector can hold before reallocation v.reserve(n) - allow vector to avoid reallocation v.insert( pointer, value ) - inserts value before pointer. template <class It> v.insert( pointer, It begin, It end). Generic Programming and the STL

18. 2.1 vector Sequence Container (III) • vector functions and operations v.erase( pointer) • remove element from container v.erase( pointer1, pointer2) • remove elements starting from pointer1 and up to (not including) pointer2. v.clear() • erases entire container. v[elementNumber] =value; • assign value to an element v.at[elementNumber] =value; • as above, with range checking • throws out_of_bounds exception Generic Programming and the STL

19. 2.2 list Sequence Container • listcontainer • #include <list> • efficient insertion/deletion anywhere in container • doubly-linked list • bidirectional iterators • There exists also a non-standard slist • singly-linked list • forward iterator Generic Programming and the STL

20. 2.2 list Sequence Container (II) • list functions for listObject and otherObject listObject.sort() • sorts in ascending order listObject.splice(iterator, otherObject); • inserts values from otherObject before location of iterator listObject.merge(otherObject) • removes otherObject and inserts it into listObject, sorted listObject.unique() • removes duplicate elements listObject.swap(otherObject); • exchange contents listObject.assign(iterator1, iterator2) • replaces contents with elements in range of iterators listObject.remove(value) • erases all instances ofvalue Generic Programming and the STL

21. 2.3 deque Sequence Container • deque ("deek") - double-ended queue • #include <deque> • indexed access using [] • efficient insertion/deletion in front and back • non-contiguous memory: "smarter" pointers • same basic operations as vector • adds push_front / pop_front- insertion/deletion at beginning of deque Generic Programming and the STL

22. 3 Associative Containers • Associative containers • provide direct access to store and retrieve elements via keys (search keys) • 4 types: multiset, set, multimap and map • keys in sorted order • multiset and multimap allow duplicate keys • multimap and map allow keys and associate values Generic Programming and the STL

23. Excursion: Function Objects template <class T> struct less { bool operator()(const T& lhs, const T& rhs) const { return lhs < rhs; } }; less<int> is_smaller; if(is_smaller(45, 34)){..} Generic Programming and the STL

24. 3.1 multiset Associative Container • multiset - fast storage, retrieval of keys • allows duplicates • Ordering by comparator function object less<type> - sorts keys in ascending order multiset< int, less<int> > integers; • CGAL comparator function objects typedef CGAL::Cartesian<double> K; multiset< K::Point_2, K::Compare_xy_2 > points; Generic Programming and the STL

25. 3.1 multiset Associative Container (II) • Functions for multiset object msObject • msObject.insert(value) - inserts value • msObject.find(value) - returns iterator to first instance of value, or msObject.end() • msObject.lower_bound(value)- returns iterator to first location ofvalue • msObject.upper_bound(value)- returns iterator to location after last occurrence of value • for a pair object p p = msObject.equal_range(value) • sets first and second to lower_bound and upper_bound for a given value Generic Programming and the STL

26. 3.2 set Associative Container • set • implementation identical to multiset • unique keys - duplicates ignored and not inserted • supports bidirectional iterators (but not random access) • #include<set> Generic Programming and the STL

27. 3.4 map Associative Container • map • fast storage/retrieval of unique key/value pairs • #include<map> • one-to-one mapping (duplicates ignored) • use [] to access values for map<int, double> M; M[30] = 4000.21; sets the value of key 30 to 4000.21 • if subscript not in map, creates new key/value pair • Efficiency remark: Use insert to insert, operator[] to update Generic Programming and the STL

28. 3.5 Non Standard Associative Container • hash_(multi)set, hash_(multi)map • Not part of the standard, but provided by some STLs • REALLY fast storage/retrieval of unique key/value pairs • Based on hashing and not on binary trees • No order, but provide iterators • CGAL::Unique_hash_map • Does not provide removal, only insertion • No order, no iterators • Designed for speed, and minimal memory consumption Generic Programming and the STL

29. 4 Container Adapters • container adapters: stack, queue, priority_queue • not first class containers • do not support iterators • do not provide actual data structure • programmer can select implementation of the container adapters • have member functions push() and pop() Generic Programming and the STL

30. 4.1 stack Adapter • stack • insertions and deletions at one end • last-in-first-out data structure • implemented with vector, list, and deque (default) • #include<stack> • Declarations stack<type, vector<type> > myStack; stack<type, list<type> > myOtherStack; stack<type> anotherStack; Generic Programming and the STL

31. 4.2 queue Adapter • queue - insertions at back, deletions at front • first-in-first-out data structure • implemented with list or deque • #include<queue> • Functions • push(element) - (push_back) add to end • pop(element) - (pop_front) remove from front • empty() - test for emptiness • size() - returns number of elements • Example: queue <double> values; //create queue values.push(1.2); // values: 1.2 values.push(3.4); // values: 1.2 3.4 values.pop(); // values: 1.2 Generic Programming and the STL

32. 4.3 priority_queue Adapter • insertions in sorted order, deletions from front • implemented with vector or deque • highest priority element always removed first • heapsort puts largest elements at front • less<T> by default, programmer can specify another • Functions • push - (push_back then reorder elements) • pop - (pop_back to remove highest priority element) • size • empty Generic Programming and the STL

33. 5 Algorithms • Before STL • class libraries were incompatible among vendors • algorithms built into container classes • STL separates containers and algorithms • easier to add new algorithms • more efficient, avoids virtual function calls Generic Programming and the STL

34. 5.1 for_each, accumulate, transform • for_each(iterator1, iterator2, function); • list<int> L(..);int sum = accumulate(L.begin(), L.end(), 0, plus<int>()); • transform(istream_iterator<Point>(cin), istream_iterator<Point>(), ostream_iterator<double>(cout), mem_fun_ref(Point::x)); Generic Programming and the STL

35. 5.2 Basic Searching Algorithms • find(iterator1, iterator2, value) • returns iterator pointing to first instance of value • find_if(iterator1, iterator2, function) • like find, but returns an iterator whenfunction returns true. • binary_search(iterator1, iterator2, value) • searches an ascending sorted list for value using a binary search Generic Programming and the STL

36. 5.3 Sorting Algorithms • sort(begin, end) • partial_sort(begin, begin+N, end) • finds first N and sorts them • nth_element(begin, begin+N, end) • finds first N, not sorted • partition(begin, end, function) • splits in two intervals • stable_sort, stable_partition • Remarks • All take optionaly a comparison function • std::sort is faster than clib sort Generic Programming and the STL

37. 5.4 equal, mismatch,lexicographical_compare • Functions to compare sequences of values • equal • returns true if sequences are equal (uses ==) • returns false if of unequal length equal(iterator1, iterator2, iterator3); • compares sequence from iterator1 up toiterator2with the sequence beginning at iterator3 • Containers can be of different types Generic Programming and the STL

38. 5.5 fill, fill_n, generate, generate_n • STL functions, change containers. • fill - changes a range of elements (from iterator1 to iterator2) tovalue • fill(iterator1, iterator2, value); • fill_n - changes specified number of elements, starting at iterator1 • fill_n(iterator1, quantity, value); • generate - like fill, but calls a function for value • generate(iterator1, iterator2, function); • generate_n - like fill_n, but calls function for value • generate(iterator1, quantity, value) Generic Programming and the STL

39. 5.6 swap, iter_swap and swap_ranges • swap(element1, element2) - exchanges two values swap( a[ 0 ], a[ 1 ] ); • iter_swap(iterator1, iterator2) - exchanges the values to which the iterators refer • swap_ranges(iterator1, iterator2, iterator3) - swap the elements from iterator1 to iterator2 with the elements beginning at iterator3 Generic Programming and the STL

40. 5.7 copy_backward, merge, unique, reverse • copy_backward(iterator1, iterator2, iterator3) • copy the range of elements fromiterator1 to iterator2 into iterator3, but in reverse order. • merge(iter1, iter2, iter3, iter4, iter5) • ranges iter1-iter2 and iter3-iter4 must be sorted in ascending order. • merge copies both lists into iter5, in ascending order. • unique(iter1, iter2) - removes duplicate elements from a sorted list, returns iterator to new end of sequence. • reverse(iter1, iter2)- reverses elements in the range of iter1 to iter2. Generic Programming and the STL

41. 5.8 Remove does (not) Remove • Member function:L.remove(Point(0,0)); • Algorithm moves at end:list<Point> L(istream_iterator<Point>(cin), istream_iterator<Point>());list<Point>::iterator eit;eit = remove(L.begin(), L.end(), Point(0,0));L.erase(eit, L.end()); Generic Programming and the STL

42. 6 Other Features of the STL • Streams • strings, wide strings • locales (for internationalization) • numerical • valarray Generic Programming and the STL

43. 7 References • N.M. Josuttis, The C++ Standard Library, Addison-Wesley 2001 • S.Meyers, Effective STL, Addison-Wesley 2001 • www.sgi.com/STL • www.boost.org • www.stlport.org • www.dinkumware.com Generic Programming and the STL