C++ Sets and Multisets Set containers automatically sort their elements automatically. Multisets allow duplication of elements whereas sets do not. Usually, the sort implementation is a binary tree which implies that elements cannot be changed directly. Thus, an element has to be deleted, modified, and then re-inserted. – Made up of a key or search criteria. – Use the insert() method in assigning elements, and erase() method for deletion. Also, emplace() will copy an element with the arguments passed in and return the position. – Associative container based upon sorting of the element values. – Ability to have a default sorting operation when declared. – Use the #include directive to pick up set support.

C++ Maps and Multimaps Where sets sort elements based upon the association of the value of the element itself, maps and multimaps sort elements based upon some key in the element associated with the value of the element. Multimaps allow duplicate key/value pairs where as maps do not. – The key and value of a map or multimap must be copyable/movable. – The key must be comparable based upon the sorting criteria. – Usually binary tree based sorting. – Like sets, the key cannot be changed directly due to the side effect of compromising the order. – The element must be removed, modified, and then re-inserted as is the case with a set.

C++ SetsMap Template i/f f(n) Hidden

C++ Unordered Sets and Maps Unordered containers are primarily considered hash tables where elements that are represented as part of the container are placed into the container in some arbitrary order. This is to say the container is a bucket that that elements are dropped into and then retrieved in some random fashion. With regular maps and sets, there is no sorting criteria that is followed by the user in order to place an element into a specific position – it is hidden from the user of the class. – Must use the #include directive with and/or with possibly the include needed. – Hash tables use a hash code associated with a linked list of some sort. – There must be at least a forward iterator. – Rehashing is possible either through a complete rearrangement of data or some incremental rearrangement.

C++ Unordered Container (Hash Table) Hash f(n) Hidden Template i/f

C++ – No direct access operations provided and indirect access with iterators makes key values constant. – As a developer, the things that can be defined are: the number of buckets, user defined hash function, equivalence function, and load factor. Also, outside of the load factor, a user can force a rehash. See “When to Use Which Container”, Section 7.12, pgs. 392 – 395, The C++ Standard Library (Josuttis).

C++ Function Objects and Lambdas – Function Object: functor (f(n)) has a call to operator() f(n) object may have state f(n) object has its own type f(n) object is usually quicker than a function pointer. – Lambdas Convenient method of specifying algorithm and function details Very simple way of defining some behavior that may only be done is some other cryptic fashion

C++ Iterators Iterators are objects that traverse sequences of elements and are defined with a formal API based upon element references (pointers). Output Iterators Input Iterators Forward Iterators Bidirectional Iterators Random Access Iterators – Output Iterators Output iterators only steps forward with a write. An output iterator can only iterate over a range of elements once. Common output iterators are ostreams and inserters (e.g. cout). – Input Iterators Input iterators only steps forward with a read and only reads the element once. Common input iterators are istreams such as ‘cin’ – Forward Iterators Input iterators that can be compared to another input iterator pointing to the same element. Forward lists and unordered containers provide these types of iterators.

C++ – Bidirectional Iterators Forward iterators that can also traverse elements in the reverse or backward direction. List, maps, and set containers provide bidirectional iterators. – Random Access Iterators Ability to perform iterator arithmetic as well as all of the functions that bidirectional iterators perform. All of the random access containers can perform these type of iterators (i.e. array, vector, deques and strings).

C++

Algorithms C++ Algorithms process iterator ranges and allow operations passed into the algorithm that will be used internally. The ranges for iterators must be valid which is usually specified as.begin() and.end() of the same iterator. 1.Modifying, Removing, and Non-modifying algorithms 2.Sorting, Mutating, and Sorted-range algorithms 3.Numeric algorithms – Modifying, Removing, and Non-modifying algorithms Modifying algorithms all change in values of elements whereas the Non-modifying algorithms do not. In general Non-modifying algorithms return some predicate return value or something about the element(s) (e.g. find_if() or count() ) – Sorting, Mutating, and Sorted-range algorithms Mutating algorithms change the order of elements by changing the values of the elements (e.g. assigning new values or swapping values). Sorting algorithms are special cases of mutating algorithms in that the order of elements are changed but not due to changing values of elements rather the indexes of where the elements can be found change.

C++ – Numeric algorithms Algorithms that combine the values of numeric elements in various ways. For instance, accumulate() will process the sum of all of the elements. Specific Algorithms – for_each() template Function for_each (InputIterator first, InputIterator last, Function fn); first, last Input iterators to the initial and final positions in a sequence. The range used is [first,last), which contains all the elements between first and last, including the element pointed by first but not the element pointed by last. fn Unary function that accepts an element in the range as argument. This can either be a function pointer or a move constructible function object. Its return value, if any, is ignored. – count() template typename iterator_traits ::difference_type count (InputIterator first, InputIterator last, const T& val);

C++ first, last Input iterators to the initial and final positions of the sequence of elements. The range used is [first,last), which contains all the elements between first and last, including the element pointed by first but not the element pointed by last. val Value to match. T shall be a type supporting comparisons with the elements pointed by InputIterator using operator== (with the elements as left-hand side operands, and val as right-hand side). – find() template InputIterator find (InputIterator first, InputIterator last, const T& val); first, last Input iterators to the initial and final positions in a sequence. The range searched is [first,last), which contains all the elements between first and last, including the element pointed by first but not the element pointed by last. val Value to search for in the range. T shall be a type supporting comparisons with the elements pointed by InputIterator using operator== (with the elements as left-hand side operands, and val as right-hand side).

C++ – search() template ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2); template ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); first1, last1 Forward iterators to the initial and final positions of the searched sequence. The range used is [first1,last1), which contains all the elements between first1 and last1, including the element pointed by first1 but not the element pointed by last1. first2, last2 Forward iterators to the initial and final positions of the sequence to be searched for. The range used is (first2,last2). For (1), the elements in both ranges shall be of types comparable using operator== (with the elements of the first range as left-hand side operands, and those of the second as right-hand side operands). pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the same order), and returns a value convertible to bool. The returned value indicates whether the elements are considered to match in the context of this function. The function shall not modify any of its arguments. This can either be a function pointer or a function object.

C++ – remove() template ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val); first, last Forward iterators to the initial and final positions in a sequence of move-assignable elements supporting being compared to a value of type T. The range used is [first,last), which contains all the elements between first and last, including the element pointed by first but not the element pointed by last. val Value to be removed. – sort() template void sort (RandomAccessIterator first, RandomAccessIterator last); template void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp); first, last Random-access iterators to the initial and final positions of the sequence to be sorted. The range used is [first,last), which contains all the elements between first and last, including the element pointed by first but not the element pointed by last. RandomAccessIterator shall point to a type for which swap is properly defined and which is both move-constructible and move-assignable.