A quote, and footnote, from The Design and Evolution of C++, by Bjarne Stroustrup (1995):

Transcription

1 The Standard Library A quote, and footnote, from The Design and Evolution of C++, by Bjarne Stroustrup (1995): I would like to see list and associative array (map) templates in the standard library. However, as of Release 1.0 these classes may be lost due to the urgency of completing the core language in a timely fashion. 1 1 Here I have the great pleasure of eating my words! The committee did rise to the occasion and approved a splendid library of containers, iterators, and fundamental algorithms designed by Alex Stepanov. This library, often called the STL, is an elegant, efficient, formally sound, and well-tested framework for containers and their use. The addition of templates to C++ facilitated the development of containers that could support any data type, and do so efficiently. This greatly enhances the power of C++, placing it in a class by itself. This document describes some of the features of the standard library container classes. For a more thorough discussion and up-to-date releases of the STL, consult the following references: The C++ Programming Programming Language, by Bjarne Stroustrup The definitive reference for C++, extensive coverage of the STL is included. The C++ Standard Library, by Nicolai M. Josuttis An excellent tutorial/reference for the STL that's easy to read and understand. Silicon Graphics version of the STL, adopted by Microsoft for Visual C++ is available at this web site. You'll also extensive guides and tutorials for the STL. Ports of the STL to several environments are available at this web site. Container classes contain a collection of elements and support operations such as insert and erase to add or delete objects from the container. The elements may stored in an array, a linked list, or a binary tree. Elements are accessed with iterators. An iterator can be thought of as a pointer to the element being accessed. In some cases this is the actual implementation. Operations, such as pre and post-increment, can be used with iterators to index to the next element. For example: list<int> c; list<int>::const_iterator i;... for (i = c.begin(); i!= c.end(); ++i) cout << *i << endl; This illustrates a list container that stores elements in a linked list. Collection c is defined to contain integers. All containers have iterator and const_iterator types. Use const_iterator if code does not modify the referenced object. All containers also have begin and end member functions. The begin function returns an iterator designating the first element in the container, and the end function returns an iterator designating one past the last element. Dereference the iterator to access an element referenced by an iterator. If the container holds structures, use the structure dereferencing operator (i->value). The same code, using a vector (array) follows:

2 vector<int> c; vector<int>::const_iterator i;... for (i = c.begin(); i!= c.end(); ++i) cout << *i << endl; To facilitate changes and simplify coding it is often convenient to define a type for the collection. typedef list<int> Data; Data c; Data::const_iterator i;... for (i = c.begin(); i!= c.end(); ++i) cout << *i << endl; Iterators for each class are implemented in a similar manner, so it is easy to switch between different containers. Iterators can be used with algorithms to perform a task. For example, the following code will sort the contents of a container: sort(c.begin(), c.end()); Iterator ranges, such as the range specified in the sort algorithm, supply an open range [beg,end). This notation indicates that the first element, beg, is included in the range, and the last element, end, is not included in the range. Since c.end() in this example references one past the last element, the entire container is sorted. If the end of a range were to be included the last element, this would cause problems in the iterator implementation. Consider the following: for (i = c.begin(); i <= c.end(); ++i) cout << *i << endl; This code would be correct if c.end() referenced the last element in a range. However, support is required for the less-than-or-equal-to operator for this iterator. It's easily done if the underlying implementation is an array. For linked lists and trees this is problematic since addresses associated with a node in a list or tree do not imply any ordering. Notice the use of the pre-increment operator. Although a post-increment operator would also work, it is less efficient. For an operation such as ++i the iterator increments to the next element, then returns the iterator. If instead we specify i++ the iterator must save its state, increment to the next element, then return the saved state. This extra step can easily be avoided by using the preincrement form of the operator. The overriding priority in library design is efficient execution. In every case where there was a choice between safety and efficiency, efficiency was preferred. For example, the pop_back function in the vector class that deletes the last element in a vector assumes that there is a valid element to delete. If the vector is empty, and this function is called, results are undetermined. For a safer container, write a wrapper that performs the desired checking. The standard library is in the std namespace. To simplify presentation, the scope resolution for this namespace has been omitted in this paper.

3 Useful Tools Pair The pair struct, defined in the <utility> header, combines two values in one structure. This facilitates passing and returning two arguments at once. Since it s a struct we can access the data members directly. This is best illustrated by example. Example 1 pair<int, double> x(5, 2.5); Pair x is initialized with values 5 and 2.5. Example 2 pair<int, double> x; x.first = 5; x.second = 2.5; Pair x is initialized with values 5 and 2.5. Example 3 pair<double, double> circarea(double radius) { pair<double, double> x; x.first = 2 * 3.14 * radius; x.second = 3.14 * radius * radius; return x; pair<double, double> p = circarea(10.0); cout << "circumference = " << p.first << ", area = " << p.second << endl; The function circarea computes the circumference and area of a circle, and returns both values as a pair. Example 4 double distance(const pair<double, double>& p) { return sqrt(p.first * p.first + p.second * p.second); cout << distance(make_pair(3.0, 4.0)) << endl; Convenience function make_pair is invoked to create a pair that is passed to the distance function. Min/Max The min and max functions, provided in the <algorithm> header, compare values and return the minimum or maximum value respectively. Both values must be of the same type. template <class T> inline const T& min (const T& a, const T& b) { return b < a? b : a; template <class T> inline const T& max (const T& a, const T& b) { return a < b? b : a;

4 Swap The swap function, provided in the <algorithm> header, swaps two values of the same type. template <class T> inline void swap(t& a, T& b) { T tmp(a); a = b; b = tmp; Containers Overview Containers can be classified as sequential or associative. Sequential containers consist of an ordered collection where the position of each element depends on the order of insertion. of sequential containers include vector, deque (rhymes with check), and list. Associative containers are sorted collections where the position of each element depends on its value. of associative containers include set, multiset, map, and multimap. Common Operations All container classes support the following operations. Initialize T c T c1(c2) T c(beg,end) empty container c1 = copy of c2 create c with copies of [beg,end) c.~t() delete all elements c.size() number of elements in container c.empty() true if container is empty (faster than size == 0) Compare c1 == c2 comparison operator == c1!= c2 comparison operator!= c1 < c2 comparison operator < c1 > c2 comparison operator > c1 <= c2 comparison operator <= c1 >= c2 comparison operator >= Assign/Swap c1 = c2 c1.swap(c2) swap(c1,c2) assignment operator swap data between c1, c2: O(1) swap data between c1, c2: O(1) Iterators c.begin() returns iterator &c[first] c.end() returns iterator &c[last + 1] c.rbegin() returns reverse iterator &c[last] c.rend() returns reverse iterator &c[first 1]

5 Vector The vector container is typically implemented as a dynamic array that can grow in one direction. The following operations are supported: size and capacity c.capacity() c.reserve(n) random access c[index] c.at(index) push/pop c.front() c.back() c.push_back(elem) c.pop_back() insert/erase c.insert(pos,elem) c.insert(pos,n,elem) c.insert(pos,beg,end) c.erase(pos) c.erase(beg,end) c.clear() c.resize(n) c.resize(n,elem) returns max number of elements w/o reallocation increases capacity to n elements references c[index] references c[index] with range checking returns first element returns last element append elem at end delete last element insert elem at position pos insert n copies of elem at position pos insert elements [beg,end) at position pos delete elem at pos, return pointer to successor delete elems [beg,end), return pointer to successor delete all elements increase size to n elements using default constructor increase size to n elements with elem as a value Push/pop operations at the end of the vector take constant time unless the array must be extended. If there is insufficient contiguous space to extend the array, then another array is allocated, the elements are copied to the new array, and the old array is deleted. To preclude this possibility, use reserve to pre-allocate sufficient space. There are no push_front or pop_front operations, as they would be very inefficient. Insert/erase operations at random locations execute in linear time. Subscripts can be used for direct access to vector elements. However, the element must already exist prior to access. That is, subscripts should be in the range 0.. (c.size() 1). #include <vector> typedef vector<int> Collection; Collection c; // append c.push_back(5); c.push_back(6); c.push_back(7); c[1] = c[0] + c[2]; cout << c.front() << endl; // output: 5 cout << c.back() << endl; // output: 7 c.pop_back(); cout << c.back() << endl; // output: 12 // iterator, output: 5 12 Collection::const_iterator i; for (i = c.begin(); i!= c.end(); ++i) cout << *i << " ";

6 // direct access, output: 5 12 Collection::size_type size = c.size(); Collection::size_type j; for (j = 0; j < size; ++j) cout << c[j] << " "; Deque A deque (rhymes with check) is a double-ended queue that can grow in both directions. The interface is the same as the vector class, except there are no capacity and reserve functions, and deques include the following push/pop operations: push/pop c.front() c.push_front(elem) c.pop_front() c.back() c.push_back(elem) c.pop_back() returns first element insert elem at beginning delete first element returns last element append elem at end delete last element Deques are often implemented as a set of arrays. Initially one array is allocated, and the first push places an element at the middle of the array. Subsequent pushes can add elements in both directions. When the array bounds is encountered, an additional array is allocated. Push/pop operations at both ends of the deque take constant time. Insert/erase operations at random locations execute in linear time. Direct access is provided, but is not as fast as direct access with the vectors since an extra level of indirection is required to determine which array holds the element. #include <deque> typedef deque<int> Collection; Collection c; // push c.push_back(6); c.push_back(7); c.push_front(5); c.push_front(4); c[1] = c[0] + c[2]; c.pop_front(); cout << c.front() << endl; // output: 10 c.pop_back(); cout << c.back() << endl; // output: 6

7 // iterator, output: 10 6 Collection::const_iterator i; for (i = c.begin(); i!= c.end(); ++i) cout << *i << " "; // direct access, output: 10 6 Collection::size_type size = c.size(); Collection::size_type j; for (j = 0; j < size; ++j) cout << c[j] << " "; List A list is implemented as a doubly linked list. The following operations are supported: push/pop c.front() c.push_front(elem) c.pop_front() c.back() c.push_back(elem) c.pop_back() insert/erase c.insert(pos,elem) c.insert(pos,n,elem) c.insert(pos,beg,end) c.erase(pos) c.erase(beg,end) c.clear() c.remove(val) c.remove_if(op) c.resize(num) c.resize(num,elem) returns first element insert elem at beginning delete first element returns last element append elem at end delete last element insert elem at position pos (returns pos of new element) insert n copies of elem at pos (returns nothing) insert at pos elements [beg,end) (returns nothing) delete elem at pos, return pointer to successor delete elems [beg,end), return pointer to successor delete all elements delete all elements with value val delete all elements for which op(elem) is true increase size to num elements using default constructor increase size to num elements initial with elem sort/merge c.sort() sort, comparing with operator < c.sort(op) sort, comparing with function op(e1,e2) c1.merge(c2) move c2 to c1, merging sorted lists c.reverse() reverse order of elements c.unique() remove duplicates of consecutive elements c.unique(op) remove duplicates for which op(e1,e2) is true Push/pop operations at both ends of the list take constant time. Insert/erase operations at random locations take constant time since only pointer adjustments are needed. The list class does not support direct access, so the sort algorithm may not be utilized. For this reason a sort member function is included with the list class that does a stable sort in O(n lg n) time on average. Typically a merge sort is done, manipulating the list with splice operations. See Josuttis for a description of splice operations. #include <list> typedef list<int> Collection; Collection c; // push c.push_back(6); c.push_back(7); c.push_front(5);

8 c.push_front(4); c.pop_front(); cout << c.front() << endl; // output: 5 c.pop_back(); cout << c.back() << endl; // output: 6 // iterator, output: 5 6 Collection::const_iterator i; for (i = c.begin(); i!= c.end(); ++i) cout << *i << " "; // reverse order of elements c.reverse(); // sort elements c.sort(); Set/MultiSet Sets and multisets are ordered collection of keys the position of each key in the set is determined by its value. Keys must be unique in sets, but duplicate keys are allowed in multisets. Sets and multisets are typically implemented as a balanced binary tree. The following operations are supported: insert functions, sets insert(elem) insert(pos,elem) returns pair<iterator,bool> (see below) inserts elem and returns iterator to inserted element insert functions, multisets insert(elem) inserts elem and returns iterator to inserted element insert(pos, elem) inserts elem and returns iterator to inserted element erase c.erase(elem) c.erase(pos) c.erase(beg,end) c.clear() search count(elem) find(elem) lower_bound(elem) upper_bound(elem) equal_range(elem) delete all elements with value elem delete element at position pos delete elements on range [beg,end) delete all elements returns number of elements with value elem returns position of first element with value elem returns position of first element >= elem returns position of first element > elem returns pair<lower_bound,upper_bound> No push/pop operations are allowed on sets, as the position of an element is determined by its value. Insert operations may provide a position, but this is taken as a hint to improve insertion time. Insert/erase operations at random locations take O(lg n) time. The insert operation for sets returns a pair. The first member of the pair returns the position of the newly inserted element, and the second member of the pair indicates whether or not the operation was successful. Insertion can fail in sets if an attempt is made to insert duplicate keys. Erase operations for vector, deque, and list return a pointer to the successor element. This is not done in sets or multisets as the operation would be too expensive.

9 By default, elements are stored in increasing order using the < operator. The template definition for sets and multisets includes a Compare parameter: template <class T, class Compare = less<t>,...> Where less<t> is defined as template<class T> struct less { bool operator() (const T& x, const T& y) const { return x < y; ; Override the 2 nd parameter for a different sort order. e.g., set<int,greater<int> > s; will store integer elements in decreasing order. An extra space is required between each > so it won t be parsed as the binary shift operator >>. #include <set> typedef set<int> Collection; Collection c; c.insert(6); c.insert(7); c.insert(5); c.insert(4); // attempt to insert a duplicate key pair<collection::iterator,bool> status; status = c.insert(5); if (status.second) cout << "Success!" << endl; // output collection in increasing order Collection::const_iterator i; for (i = c.begin(); i!= c.end(); ++i) cout << *i << " "; // delete entries 5, 6, 7 Collection::iterator pos1, pos2; pos1 = c.find(5); pos2 = c.find(7); c.erase(pos1,++pos2); Map/MultiMap Maps and multimaps are ordered collections of key/value pairs the position of each pair in the map is determined by its key. The keys must be unique in maps, but duplicate keys are allowed in multimaps. Maps and multimaps are typically implemented as a balanced binary tree. Insert/erase operations at random locations take O(lg n) time. Maps are similar to sets, only iterators reference key/value pairs. You can change the value, but not the key, using iterators. To change a key, first erase the old record, then insert a new one with the revised key. By default, elements are stored in increasing order using the < operator. The template definition for maps and multimaps is as follows:

10 template <class Key, class T, class Compare = less<key>,...> Override the 3 rd parameter for a different sort order. The following illustrates a thesaurus implemented as a multimap. #include <map> #include <string> typedef multimap<string,string> Collection; Collection c; c.insert(make_pair("big", "large")); c.insert(make_pair("big", "huge")); c.insert(make_pair("enormous", "huge")); // alter the value of a key/value pair Collection::iterator pos = c.find("enormous"); if (pos!= c.end()) pos->second = "megalithic"; // print all values for key "big" string t("big"); for (pos = c.lower_bound(t); pos!= c.upper_bound(t); ++pos) cout << pos->second << endl; // print all keys for value "huge" string u("huge"); for (pos = c.begin(); pos!= c.end(); ++pos) if (pos->second == u) cout << pos->first << endl; // delete all elements with value "huge" string v("huge"); pos = c.begin(); while (pos!= c.end()) { if (pos->second == v) c.erase(pos++); else ++pos; Container Adapters // is this okay? Stack A stack supports a last-in-first-out (LIFO) queue and is based on the deque class. Push/pop operations are done in constant time. The following operations are supported: push/pop c.push(elem) c.top() c.pop() size c.size() c.empty() inserts an element into the stack returns the top of stack deletes the top of stack (no return value) returns number of elements in stack returns true if stack is empty

11 #include <stack> stack<int> s; s.push(1); s.push(2); s.push(3); cout << s.top() << endl; // 3 s.pop(); cout << s.top() << endl; // 2 s.pop(); cout << s.top() << endl; // 1 s.pop(); s.push(10); s.push(20); s.push(30); // output and pop all elements while (!s.empty()) { cout << s.top() << endl; s.pop(); Queue A queue supports a first-in-first-out (FIFO) queue and is based on the deque class. Push/pop operations are done in constant time. The following operations are supported: push/pop c.push(elem) c.front() c.back() c.pop() size c.size() c.empty() #include <queue> queue<int> q; q.push(1); q.push(2); q.push(3); cout << q.front() << endl; // 1 cout << q.back() << endl; // 3 q.pop(); cout << q.front() << endl; // 2 q.pop(); cout << q.front() << endl; // 3 q.pop(); inserts an element on back of the queue returns the element at the front of the queue returns the element at the back of the queue deletes element from front of the queue returns number of elements in queue returns true if queue is empty Priority Queue A priority queue returns elements in an ordered sequence. Priority queues are usually implemented as heaps and based on the vector class. Push/pop operations take O(lg n) time. The following operations are supported:

12 push/pop c.push(elem) c.top() c.pop() size c.size() c.empty() inserts an element into the priority queue returns the next element in the priority queue deletes an element from the priority queue returns number of elements in priority queue returns true if priority queue is empty By default the largest element is returned first. To change the order, modify the 3 rd template parameter: priority_queue<class T, vector<t>, class Compare = less<key> > The default uses the vector class as a basis, and invokes the less function object. Changing less to greater will reverse the order causing the priority queue to return the smallest element first. #include <queue> priority_queue<int> pq; pq.push(2); pq.push(1); pq.push(3); cout << pq.top() << endl; // 3 pq.pop(); cout << pq.top() << endl; // 2 pq.pop(); cout << pq.top() << endl; // 1 pq.pop(); Iterator Adapters Iterator adapters allow algorithms to operate in reverse, utilize insert mode, and access I/O streams. Random Access Iterators Iterators associated with the vector and deque containers are random access and can participate in arithmetic expressions including iter + n iter n iter += n iter1 < iter2 iter1 <= iter2 n + iter n iter iter -= n iter1 > iter2 iter1 >= iter2 You can also take the distance between two iterators. iter1 iter2 This returns the distance, or the number of container objects, between the two iterators. Similar operations are possible with non random-access containers, such as the list container, with the following functions. advance(pos, n) distance(pos1, pos2) // advance iterator by n objects // distance in objects between two iterators In this case the iterator is incremented (++ operator) to achieve the desired result.

13 Reverse Iterators The following functions support indexing through a collection in a reverse direction: c.rbegin() c.rend() returns position of last element returns position before first element Reverse iterators (reverse_iterator) change the sense of the increment/decrement operators, so increment the iterator to index in reverse. // print collection, from last to first element vector<int>::reverse_iterator i; for (i = c.rbegin(); i!= c.rend(); ++i) cout << *i << endl; Insert Iterators Use insert iterators to insert elements where a copy is normally done. The following iterators are supported: iterator calls back_inserter push_back front_inserter push_front inserter insert // establish collections // c = 1 2 c.push_back(1); c.push_back(2); // d = d.push_back(10); d.push_back(20); d.push_back(30); // e = e.push_back(10); e.push_back(20); e.push_back(30); copy (c.begin(), c.end(), d.begin()); // d = copy (c.begin(), c.end(), back_inserter(e)); // e =

14 Stream Iterators Iterators are provided that interface with I/O streams. By convention an istream argument is used for the istream_iterator for the beginning of the stream, and no arguments are used to designate the end. vector<string> c; // input strings and place them in vector "c". Stop at EOF or error. copy( istream_iterator<string>(cin), // begin() istream_iterator<string>(), // end() back_inserter(c)); // output contents of vector "c", with a newline between each element copy(c.begin(), c.end(), ostream_iterator<string>(cout, "\n"));

15 Algorithms Use algorithms to manipulate objects in containers. Most algorithms require include files <algorithm> and <functional>. The following program illustrates the use of algorithms applied to the vector container. In subsequent sections we will examine algorithms in detail. #include <string> #include <iostream> #include <vector> #include <algorithm> using namespace std; struct Employee { int empno; // employee number string name; // employee name double pay; // salary ; typedef vector<employee> Collection; bool cmpname(const Employee& e1, const Employee& e2) { return e1.name < e2.name; void output(const Employee& e) { cout << e.empno << " " << e.name << " " << e.pay << endl; class empnoequals { public: empnoequals(int empno_) : empno(empno_) { bool operator()(const Employee& e) const { return e.empno == empno; private: int empno; ; int main() { Collection emp; Employee t; // new employee t.empno = 1001; t.name = "John"; t.pay = 1000; emp.push_back(t); // assume several others have been added... // sort employees in ascending order by name sort(emp.begin(), emp.end(), cmpname); // output sorted employees for_each(emp.begin(), emp.end(), output); // find employee with empno == 1001 Collection::iterator i; i = find_if(emp.begin(), emp.end(), empnoequals(1001)); // add $10 to employee 1001's pay if (i!= emp.end()) i->pay += 10; return 0;

16 Classification Algorithms may be classified in the following categories: nonmodifying. Algorithms, such as count and find, will not change the order or value of elements in a collection. modifying. Algorithms, such as copy and replace, may change the order or value of elements in a collection. removing. Remove specified elements. mutating. Change the order of elements in a collection. sorting. Order elements in a collection based on values. sorted range. Algorithms, such as binary search, work on a sorted range of elements. numeric. Mathematical algorithms to compute sums and products. Several algorithms have a suffix that implies their function: _if suffix. A function or function object is implied. For example: find find value find_if find value that satisfies criteria of function _copy suffix. A copy of the elements is placed in another collection. reverse reverse order reverse_copy copy reversed elements to another collection Before investigating algorithms for each category, we'll examine the for_each algorithm. This algorithm may be classified as both nonmodifying and modifying. for_each The for_each algorithm iterates through the elements of a range, calling a function for each element. The algorithm is similar to the following: template<class T, class F) F for_each(t pos, T last, F op) { while (pos!= last) op(*pos++); return op; When iteration is complete, the last value of op is returned. Although the implementation for many of the algorithms is relatively short, they provide power and flexibility to the container classes. void print(int x) { cout << x << endl; void timestwo(int& x) { x = x + x; vector<int> c; // print each element for_each(c.begin(), c.end(), print); // multiply each element by two for_each(c.begin(), c.end(), timestwo);

17 Nonmodifying Nonmodifying algorithms do not change the value or position of elements in a collection. Count and find are implemented as member functions in the list class. // unary predicate bool even(int x) { return x % 2 == 0; vector<int> c; // count the number of 4's n = count(c.begin(), c.end(), 4); // count the number of even numbers n = count_if(c.begin(), c.end(), even); // find the first occurrence of the number 4 pos = find(c.begin(), c.end(), 4); // find the first occurrence of an even number pos = find_if(c.begin(), c.end(), even); // find the location of the smallest element pos = min_element(c.begin(), c.end()); // find the location of the largest element pos = max_element(c.begin(), c.end()); // binary predicate bool compareaverage(const Employee& s1, const Employee& s2) { return s1.pay < s2.pay; struct Employee { string name; double pay; ; vector<employee> c; // find student with highest pay pos = max_element(c.begin(), c.end(), compareaverage); Modifying Modifying algorithms change the contents of a collection. void timestwo(int& x) { x = x + x; // predicate function bool even(int x) { return x % 2 == 0; // copy c1 to c2 (c2 must have sufficient room) copy(c1.begin(), c1.end(), c2.begin());

18 // append c1 to the end of c2 copy(c1.begin(), c1.end(), back_inserter(c2)); // transform values in c1 (times two), and place the results in c2 transform(c1.begin(), c1.end(), c2.begin(), timestwo); // replace all instances of 4 with 8 replace(c.begin(), c.end(), 4, 8); // replace all even numbers with 0 replace_if(c.begin(), c.end(), even, 0); Removing The remove algorithm shifts elements from the end of a collection to replace removed entries. Collection size does not change, and the position of the new end-of-collection is returned. A subsequent call to erase will delete excess entries. For the list class, use the remove member function. // predicate function bool even(int x) { return x % 2 == 0; // remove all elements with value 5 to the end of the collection // state: pos = remove(c.begin(), c.end(), 5); // state: c.erase(pos, c.end()); // state: // remove all even elements to the end of the collection // state: pos = remove_if(c.begin(), c.end(), even); // state: c.erase(pos, c.end()); // state: // operations may be combined as follows: c.erase(remove_if(c.begin(), c.end(), even), c.end()); // copy all elements not equal to value 3 remove_copy(c1.begin(), c1.end(), back_inserter(c2), 3); // copy all odd numbers (predicate fails) remove_copy_if(c1.begin(), c1.end(), back_inserter(c2), even); // remove duplicates to the end of the collection pos = unique(c.begin(), c.end()); c.erase(pos, c.end()); // copy c1 to c2, eliminating any duplicates unique_copy(c1.begin(), c1.end(), back_inserter(c2)); Mutating Mutating algorithms change the order of elements in a collection. // reverse order of elements reverse(c.begin(), c.end());

19 // print elements in reverse order (collection not changed) reverse_copy(c.begin(), c.end(), ostream_iterator<int>(cout,"\n")); // rotate elements, using "begin+1" as the new first element // state: rotate(c.begin(), c.begin() + 1, c.end()); // state: // print rotated elements (collection not changed) rotate_copy(c.begin(), c.begin() + 1, ostream_iterator<int>(cout,"\n")); Sorting Sorting algorithms run in O(n lg n) time on average. Stable sorts, where the order of identical keys is not changed, runs in O(n lg n) time if there is sufficient memory, or O(n lg n * lg n) time otherwise. Use sort algorithms on containers that support random access such as vector and deque. The list class has its own sort member function. Associative containers, such as set and map, place elements in order on insertion. // binary predicate bool compare(int x, int y) { return x > y; // sort elements in collection in increasing order (operator "<") sort(c.begin(), c.end()); // sort elements in collection in decreasing order sort(c.begin(), c.end(), compare); // another way to sort elements in collection in decreasing order sort(c.begin(), c.end(), greater<int>()); // stable sort, increasing order stable_sort(c.begin(), c.end()); // stable sort, decreasing order stable_sort(c.begin(), c.end(), compare); // stable sort, decreasing order stable_sort(c.begin(), c.end(), greater<int>()); Sorted Range These algorithms assume the elements in the range specified are ordered according to a sort criteria. They may be used on containers that do not have random access, such as the list container. In this case, timing is linear as each element must be examined. Timing is logarithmic for random access containers. Algorithms lower_bound, upper_bound, and equal_range are also implemented as member functions for the associative containers. // binary predicate bool compare(int x, int y) { return x < y;

20 // Just need to know if it's there? Then do a binary_search. // Otherwise, do lower_bound, upper_bound, or equal_range. bool found = binary_search(c.begin(), c.end(), 5); bool found = binary_search(c.begin(), c.end(), 5, compare); // lower_bound returns the position of the first element >= value pos = lower_bound(c.begin(), c.end(), 5); pos = lower_bound(c.begin(), c.end(), 5, compare); // upper_bound returns the position of the first element > value pos = upper_bound(c.begin(), c.end(), 5); pos = upper_bound(c.begin(), c.end(), 5, compare); // pair.first is lower_bound // pair.second is upper_bound pair<iter,iter> p = equal_range(c.begin(), c.end(), 5); pair<iter,iter> p = equal_range(c.begin(), c.end(), 5, compare); // check whether several elements are present // returns true if c1 contains all elements listed in c2 // both c1 and c2 must be ordered bool found = includes(c1.begin(), c1.end(), c2.begin(), c2.end()); bool found = includes(c1.begin(), c1.end(), c2.begin(), c2.end(), compare); // merge ordered collections c1, c2 ==> c3 (all) // ( ), ( ) ==> ( ) merge(c1.begin(), c1.end(), c2.begin(), c2.end(), back_inserter(c3)); merge(c1.begin(), c1.end(), c2.begin(), c2.end(), back_inserter(c3), compare); // union of ordered collections c1, c2 ==> c3 // select elements in either 1 st or 2 nd collections // ( ), ( ) ==> ( ) set_union(c1.begin(), c1.end(), c2.begin(), c2.end(), back_inserter(c3)); set_union(c1.begin(), c1.end(), c2.begin(), c2.end(), back_inserter(c3), compare); // intersection of ordered collections c1, c2 ==> c3 // select elements in both 1 st and 2 nd collections // ( ), ( ) ==> ( ) set_intersection(c1.begin(), c1.end(), c2.begin(), c2.end(), back_inserter(c3)); set_union(c1.begin(), c1.end(), c2.begin(), c2.end(), back_inserter(c3), compare); // difference of ordered collections c1, c2 ==> c3 // select elements in 1 st but not in 2 nd collection // ( ), ( ) ==> ( ) set_difference(c1.begin(), c1.end(), c2.begin(), c2.end(), back_inserter(c3)); set_difference(c1.begin(), c1.end(), c2.begin(), c2.end(), back_inserter(c3), compare); // symmetric difference of ordered collections c1, c2 ==> c3 // select elements in 1 st or 2 nd but not both collections // ( ), ( ) ==> ( ) set_symmetric_difference(c1.begin(), c1.end(), c2.begin(), c2.end(), back_inserter(c3)); set_symmetric_difference(c1.begin(), c1.end(), c2.begin(), c2.end(), back_inserter(c3), compare);

21 Numeric Numeric algorithms facilitate the computation of values on collections. // add elements in collection (initialize total to 0) double sum = accumulate(c.begin(), c.end(), 0); // multiply elements in a collection (initialize total to 1, op == multiply) double product = accumulate(c.begin(), c.end(), 1, multiplies<double>()); // compute dot product of c1 and c2 double dotproduct = inner_product(c1.begin(), c1.end(), c2.begin(), 0); Function Objects Function objects, or functors, are classes that act like functions. Unlike simple functions, it is possible to store state information in a function object. In addition, a function object is a type, and this is required under some circumstances. Modify Elements Use for_each to modify elements in a collection. Example 1 adds 10 to each element in the collection. A more general solution is shown in Example 2. When for_each executes, the Add constructor is called to create a temporary object with 10 stored in value. Later, the for_each algorithm will call Add for each element, passing the element as a parameter. This will invoke operator(), passing the element, and 10 will be added to the element. As this example illustrates, function objects have state (the value 10 in this case). Example 1 void add10(int &x) { x += 10; // add 10 to each element for_each(c.begin(), c.end(), add10); Example 2 class Add { public: Add(int v) : value(v) { void operator() (int& x) const { x += value; private: int value; ; // add 10 to each element for_each(c.begin(), c.end(), Add(10)); // add 20 to each element for_each(c.begin(), c.end(), Add(20));

22 Search for Value Use find or find_if to search for an element in a collection. Use function objects to save the search value and construct the predicate for collections containing structures. Example struct Employee { string name; double pay; ; class nameequals { public: nameequals(const string& name_) : name(name_) { bool operator()(const Employee& x) const { return x.name == name; private: string name; ; pos = find_if(x.begin(), x.end(), nameequals("adams")); Ordering Criteria If you're using a primitive data type, ordering criteria can be specified using one of the built-in function object predicates such as less or greater. For more complex criteria, create your own function object as shown in the following example. Note that a simple function would not compile correctly, as the set class expects ordering criteria to be a type. Example struct Employee { string name; double pay; ; class EmployeeOrder { public: bool operator() (const Employee& s1, const Employee& s2) const { return s1.pay < s2.pay; ; typedef set<employee, EmployeeOrder> EmployeeData; EmployeeData data; Employee s; s.name = "Joe"; s.pay = 95; data.insert(s);

23 Average Value The following example iterates through a collection and outputs the numeric average. Recall that for_each returns the last value of the procedure operator. In this case it returns the last state of the Average class that contains the number and sum of the elements. Example class Average { public: // called initially to create temporary Average() : num(0), sum(0) { // called for each element void operator() (int x) { num++; sum += x; // implicit type conversion, Average to double operator double() const { return static_cast<double>(sum) / static_cast<double>(num); private: int num; // number of elements int sum; // sum of elements ; double avg = for_each(c.begin(), c.end(), Average()); cout << "average = " << avg << endl; Although this looks a bit mysterious, recall that for_each returns the functor after iteration. Since we've included a conversion to double, this code executes and the average is calculated. template<class T, class F) F for_each(t pos, T last, F op) { while (pos!= last) op(*pos++); return op; Future Work The following container classes are not part of the ANSI standard, but are supported by SGI and will probably be included in the standard library in the future: slist. A container based on a singly-linked list. hash_set, hash_multiset, hash_map, hash_multimap. Containers that utilize a hash function to access data. Specify your own hash function, and an equality function that determines whether keys are equal.