18 – Sequential Containers 4.7 Implementation of a Double- Linked List Class 4.8 Application of the list Class 4.9 Standard Library Containers 4.10 Standard Library Algorithms and Function Objects 18 – Sequential Containers

Attendance Quiz #17 Sequential Containers

Tip #18: Improve Success Ratio Sequential Containers Do the tough stuff first. Think more, code less. For big stuff, get someone’s brain wrapped around it. Under promise, over deliver. When something breaks, look at your assumptions. Before you begin coding, decide how you are going to test it. Trust your team, but ask to see. Learn how to listen. Don’t whine! (ie. Clear the Bozo bit.) No Coding after midnight!

4.8, pgs. 285-286 4.8 Application of the list Class Case Study: Maintaining an Ordered List 4.8, pgs. 285-286

Application of the list Class Sequential Containers Problem We want to maintain this list so that it will be in alphabetical order even after students have added and dropped the course. Analysis Develop a general Ordered_List class that can be used to store any group of objects that can be compared using the less-than operator. Solution Write a new Ordered_List class. Inherit the C++ list class to create a new Ordered_List class and over-ride list functions (not recommended.) Or create a new Ordered_List class that uses a C++ list to store the items. Use list functions where appropriate (delegation). Write new function where needed.

Ordered Linked List Insertion Sequential Containers Algorithm for Insertion Find the first item in the list that is greater than or equal to the item to be inserted Create an iterator that starts at the beginning of the list while the iterator is not at the end and the item at the iterator position is less than the item to be inserted Advance the iterator Insert the new item before this one.

Delegation Code for Insertion Use Delegation for the Other Functions Sequential Containers Code for Insertion Inside a declaration or a definition of a template, typename can be used to declare that a dependent name is a type. void insert(const Item_Type& an_item) { typename std::list<Item_Type>::iterator itr = a_list.begin(); while (itr != a_list.end() && *itr < an_item) ++itr; // itr points to the first item >= an_item or the end a_list.insert(itr, an_item); } Use Delegation for the Other Functions void remove(const Item_Type& item) { a_list.remove(item); } A delegate is a class or method that wraps a pointer or reference to an object instance, a member method of that object's class to be called on that object instance, and provides a method to trigger that call.

4.9, pgs. 292-295 4.9 Standard Library Containers Common Features of Containers Sequences Associative Containers Vector Implementation Revisited 4.9, pgs. 292-295

Standard Library Containers Sequential Containers The C++ standard uses the term container to represent a class that can contain objects. The term concept is used to represent the set of common requirements for a container: C++ defines a common interface for all containers and then splits the set of containers into sequential containers and associative containers. Common requirements unique to these subsets are also defined and the individual containers have their own additional requirements. Although a list and a vector have several member functions in common, they are not polymorphically, but can be used interchangeably by generic algorithms. In a sequential container, at any given time each element has a particular position relative to the other items in the container. items in a sequence (ie., a vector or a list) follow some linear arrangement. In an associative container, on the other hand, there is no particular position for each item in the container. An item is accessed by its value, rather than by its position.

4.10 Standard Library Algorithms and Function Objects The find Function The Algorithm Library The swap Function Function Objects 4.10, pgs. 297-307

The Algorithm Library Sequential Containers The standard library contains many useful template functions defined in the header <algorithm>, that use a pair of iterators to define the sequence of input values. Some of them also take function objects as parameters The template functions perform fairly standard operations on containers, such as Applying the same function to each element (for_each) Copying values from one container to another (copy) Searching a container for a target value (find, find_if) Sorting a container (sort) Summing container values (accumulate) Apply function to container objects (transform) This fragment copies the contents of a_list into a_vector: a_vector.resize(a_list.size()); copy(a_list.begin(), a_list.end(), a_vector.begin());

template<typename II, typename F> Function Behavior template<typename II, typename F> F for_each(II first, II last, F fun) Applies the function fun to each object in the sequence. The function fun is not supposed to modify its argument. The iterator argument II is required to be an input iterator. This means that the sequence is traversed only once. template<typename II, typename T> II find(II first, II last, T target) Finds the first occurrence of target in the sequence. If not found, last is returned. template<typename II, typename P> II find_if(II first, II last, P pred) Finds the first occurrence of an item in the sequence for which function pred returns true. If not found, last is returned. template<typename FI> FI min_element(FI first, FI last) FI max_element(FI first, FI last) Finds the min/max element in the sequence FI; first..last. FI is a forward iterator. template<typename II, typename OI> OI copy(II first, II last, OI result) Copies the sequence first..last into result..(result + (last - first)). II is an input iterator, and OI is an output iterator. template<typename II, typename OI, typename OP> OI transform(II first, II last, OI result, OP op) Applies op to each element of the sequence first..last and places the result in result..(result + (last - first)). template<typename II1, typename II2, typename OI, typename BOP> OI transform(II1 first1, II1 last1, II2 first2, OI result, BOP bin_op) Applies bin_op to each pair of elements of the sequences first1..last1 and first2..(first2 + (last1 - first1)) and places the result in result..(result + (last1 - first1))

template<typename T> void swap(T& a, T& b) Function Behavior template<typename T> void swap(T& a, T& b) Exchanges the contents of a and b. template<typename BI> void reverse(BI first, BI last) Reverses the sequence first..last. BI is a bidirectional iterator. template<typename RI> void random_shuffle(RI first, RI last) Randomly rearranges the contents of first..last. RI is a random-access iterator. void sort(RI first, RI last) Sorts the contents of first..last based on the less-than operator applied to pairs of elements. template<typename RI, typename COMP> void sort(RI first, RI last, COMP comp) Sorts the contents of first..last based on the binary operator COMP (a function operator). COMP is a function class that takes two arguments and returns a bool. template<typename II, typename T> T accumulate(II first, II last, T init) Computes init plus the sum of the elements in first..last. Note that this function is defined in the header <numeric>. template<typename II1, typename II2> bool equal(II1 first1, II1 last1, II2 first2) template<typename II1, typename II2, typename BP> bool equal(II1 first1, II1 last2, II2 first2, BP pred) Compares each element in the sequence first1..last1 to the corresponding elements in the sequence first2..first2 + (last1 - first1). If they are all equal, then this returns true. The second form uses the function object pred to perform the comparison.

Function Objects

Data field divisor stores the number we want to divide by Function Objects Sequential Containers The function call operator (operator()) can be overloaded by a class. A class that overloads this operator is called a function class and an object of such a class is called a function object (or functor.) As an example, we may want to find a value divisible by another value. We can create a function class Divisible_By whose constructor takes the divisor as an argument: Data field divisor stores the number we want to divide by class Divisible_By { private: int divisor; public: Divisible_By(int d) : divisor(d) {} bool operator()(int x) return x % divisor == 0; } }; The definition of operator() tests the remainder resulting from the division of the function argument (int x) by the value of divisor The expression Divisible_By(3) creates a function object that returns true if the argument passed to it is divisible by 3 The expression Divisible_By(5) creates a function object that tests for integers divisible by 5

Function Objects Sequential Containers template<typename II, typename P> II find_if(II first, II last, P pred) Finds the first occurrence of an item in the sequence for which function pred returns true. If not found, last is returned. Template parameter II is a placeholder for an input iterator; template parameter P is a placeholder for a function class with an operator() that returns a bool value. // Find first number divisible by 3 in list_1. list<int>::iterator = iter; iter = find_if(list_1.begin(), list_1.end(), Divisible_By(3)); if (iter != list_1.end()) cout << "The first number divisible by 3 is " << *iter << endl; else cout << "There are no numbers divisible by 3" <<endl; // Find first number divisible by 5 in list_1. iter = find_if(list_1.begin(), list_1.end(), Divisible_By(5)); if (iter != list_1.end()) cout << "The first number divisible by 5 is " << *iter << endl; else cout << "There are no numbers divisible by 5" << endl;

Write a template Functor named Matcher such that function calls to a Matcher object returns true if same, else false. // Define templated Matcher object. // Instantiate Matcher object isMatch. // Use isMatch to test if the number n is 5. template <typename T> class Matcher { private: T target; public: Matcher(T m) : target(m) {} bool operator()(T x) { return x == target; } }; Matcher<int> isMatch(5); if (isMatch(n)) cout << n << " == 5" << endl; else cout << n << " != 5" << endl;