1. Containers and Iterators CNS 3370 Copyright 2003, Fresh Sources, Inc.

2. All Containers... Are homogeneous Provide insert and erase capability –grow as needed Support the following methods: size_type size() const; size_type max_size() const; bool empty() const;

3. Standard Containers Sequences –vector, deque, list Container Adapters –queue, stack, priority_queue Associative Containers –set, multiset, map, multimap

4. A First Look A set example –IntSet.cpp –WordSet.cpp A vector example: –StringVector.cpp

5. Sequences vector –random access –optimal insertion/deletion at end ( push_back ) deque –random access –optimal insertion/deletion at both ends ( push_front ) list –sequential access only –doubly-linked; optimal insertion/deletion anywhere

6. All Sequences support... void resize(size_type, T = T()); T& front() const; T& back() const; void push_back(const T&); void pop_back();

7. Restricted Sequence Functions // deque and list only: void push_front(const T&); void pop_front(); //deque and vector only: T& at(size_type n);

8. Nagging Questions How does one navigate a list ? –It doesn’t have any traversal member functions! How does one use the standard algorithms on a sequence? –Don’t tell us that all the algorithms have to be repeated as member functions! The answer is…

9. Iterators Generalization of a pointer Overload at least operator!=, operator==, operator*, operator++, operator-> Some overload operator--, operator[]

10. Traversing a List list lst; … // insert some elements, then: list ::iterator p = lst.begin(); while (p != lst.end()) { // Process current element (*p), then: ++p; } All sequences provide members begin and end

11. Implementing find template Iterator find(Iterator start, Iterator past, const T& v) { while (start != past) { if (*start == v) break; ++start; } return start; } All algorithms are implemented in terms of iterators

12. Iterator Taxonomy Input Output Forward Bi-directional Random Access

13. Input Iterators Read-only access to elements Single-pass, forward traversal find expects an Input Iterator

14. The Real Implementation of find (Documentation change only) template InputIterator find(InputIterator start, InputIterator past, const T& v) { while (start != past) { if (*start == v) break; ++start; } return start; }

15. Output Iterators Write-only access to elements Single-pass, forward traversal Example: ostream_iterator: copy(a, a+n, ostream_iterator (cout,“ “));

16. Forward Iterators Both read and write access –can therefore substitute for Input or Output Iterators Multiple-pass forward traversal unique expects a Forward Iterator list ::iterator p = unique(lst.first(), lst.end());

17. Bi-directional Iterators Can do everything a Forward Iterator can Also support backwards traversal –operator--() –operator--(int) reverse requires a Bi-directional Iterator

18. Traversing a List Backwards list::iterator p = lst.end(); while (p > lst.begin()) { --p;// “advances” backwards // process *p, then: if (p == lst.begin()) break; }

19. A Better Way Reverse Iterators list::reverse_iterator p = lst.rbegin(); while (p != lst.rend()) { // process *p, then: ++p;// “advances” backwards }

20. Random Access Iterators Support Pointer Arithmetic in constant time –operator+, +=, -, -=, [],, >= sort expects a Random Access Iterator

21. How do you Sort a List? Doesn’t provide a Random Access Iterator Generic sort will fail on a list Provides its own sort member function Also merge, remove, and unique

22. What’s Wrong with this Picture? vector v1; … // fill v1, then: vector v2; copy(v1.begin(), v1.end(), v2.begin());

23. Iterator Modes Iterators work in overwrite mode by default Need an insert mode for cases like above –that calls appropriate, underlying insert operation

24. Insert Iterators Replace output calls ( operator*, operator=, etc.) with appropriate insert function back_insert_iterator –calls push_back front_insert_iterator –calls push_front insert_iterator –calls insert

25. Helper Functions back_inserter –creates a back_insert_iterator front_inserter –creates a front_insert_iterator inserter –creates an insert_iterator

26. Insert Iterator Example vector v1; … // fill v1, then: vector v2; copy(v1.begin(), v1.end(), back_inserter(v2));

27. Stream Iterators ostream_iterator –an Output Iterator copy(v1.begin(), v1.end(), ostream_iterator (cout, “ “)); istream_iterator –an Input Iterator copy(istream_iterator (cin), istream_iterator (), back_inserter(v1));

28. Container Adapters High-level abstract data types –queue, stack, priority_queue Use a sequence for implementation stack > myStack; stack & queue use deque by default priority_queue uses a vector No iterators are provided –more restricted interface

29. Associative Containers set stores unique elements test for membership multiset allows duplicates map stores pairs keys must be unique multimap allows duplicate keys Support fast (logarithmic), key-based retrieval Stored according to an ordering function less () by default can use as a sequence

30. Set Example #include using namespace std; void main() { // Populate a set: set s; s.insert("Alabama"); s.insert("Georgia"); s.insert("Tennessee");

31. // Print it out: set ::iterator p = s.begin(); while (p != s.end()) cout << *p++ << endl; cout << endl; // Do some searches: string key = "Alabama"; p = s.find(key); cout << (p != s.end() ? "found " : "didn't find ") << key << endl; key = "Michigan"; p = s.find(key); cout << (p != s.end() ? "found " : "didn't find ") << key << endl; }

32. // Output: Alabama Georgia Tennessee found Alabama didn't find Michigan

33. Map Example #include using namespace std; void main() { // Convenient typedefs: typedef map > map_type; typedef map_type::value_type element_type;

34. // Insert some elements (two ways): map_type m; m.insert(element_type(string("Alabama"), string("Montgomery"))); m["Georgia"] = "Atlanta"; m["Tennessee"] = "Nashville"; m["Tennessee"] = "Knoxville"; // Print the map: map_type::iterator p = m.begin(); while (p != m.end()) { element_type elem = *p++; cout << '{' << elem.first << ',’ << elem.second << "}\n"; } cout << endl;

35. // Retrieve via a key: cout << '"' << m["Georgia"] << '"' << endl; cout << '"' << m["Texas"] << '"' << endl; } // Output: {Tennessee,Knoxville} {Georgia,Atlanta} {Alabama,Montgomery} "Atlanta” ""

36. Word Count Example Shows the conciseness of map’s design Count the number of each word in a text file WordCount.cpp

37. Strict Weak Orderings Associative containers (set, map, multi_set, multi_set) require comparators that define a strict weak ordering –Like less ( ) (which calls operator<( )) –Never use <= or anything like it! Definition: f(x,y) is a s.w.o if: –f(x,x) = false(irreflexive) –f(x,y) = !f(y,x)(anti-symmetric) –f(x,y) && f(y,z) => f(x,z)(transitive)

38. Equivalence vs. Equality Equality uses operator== –Used by most algorithms (find, etc.) Equivalence is based on a s.w.o, f( ) –x and y are equivalent iff !f(x,y) && !f(y,x) –That’s how set and map decide whether an element is already in there or not –Example: ignoring non-alpha characters in a string –See swo.cpp

39. Applications

40. Grid A Sample Application Graphs y = f(x) Models the x-y plane as rows of characters In other words, a vector of vectors of char Illustrates insert iterators, reverse iterators, random acccess iterators, stream iterators, fill_n(), fill(), for_each(), copy() See grid.cpp

41. Grid Output | * | | * | | * | | * | ** **** +--------------

42. Duplicate Word Filter Like UNIX’s uniq Except it processes unsorted sequences Need a way to detect duplicate lines without disturbing original line order Illustrates ordering predicates, index vectors, generate_n(), stable_sort(), sort(), insert iterators, stream iterators, uniq() See uniq2.cpp –Data on next slide

43. Sample Data Input each peach pear plum i spy tom thumb tom thumb in the cupboard i spy mother hubbard Output each peach pear plum i spy tom thumb in the cupboard mother hubbard

44. uniq2 What data structure(s)? –Why won’t a set suffice? Accesses lines through an index Sorts the index based on line content, then removes adjacent duplicates with the unique algorithm Re-sorts the surviving indexes numerically to adhere to original order