STL Algorithms algorithms independent of containers

STL Algorithms Description independent of container types: operate on iterators –operate on half-open range of elements of a container specified by iterators often behavior can be modified through callbacks – references to code callbacks –function pointers (C-style) –function objects (functors) –lambda expressions (C++11) most algorithms are declared in, some are in 2

Algorithm Example: find looks for specific element in range needs find(beginRange, endRange, toFind) returns iterator to first matching element in range of the container –if associative – not necessarily first, use lower_bound if not found – returns endRange (past last element) linear complexity find() method in map and set is faster (logarithmic), use it instead find() method in list should be used instead 3

find_if with Function Pointer Callback find_if(beginRange, endRange, condition) returns iterator to first element in range satisfying condition third parameter is a callback may be the name of a function (function pointer) –need to accept element type –need to be a predicate (return boolean) example: vector vect; … auto it=find_if(vect.begin(), vect.end(), moreThan5); … bool moreThan5(int elem){ return elem>5; } 4

Lambda Expressions anonymous function defined in C++11 syntax: [capture] -> returnType (parameters){body} capture – passing discipline and (optionally) name of variables taken from outside of scope of the lambda expressions –[] no variables defined. Attempting to use any external variables in the lambda is an error clang/gcc apparently still capture external variables, it is not standard –[x, &y] x is captured by value, y is captured by reference –[&] any external variable is implicitly captured by reference –[=] any external variable is implicitly captured by value compiler may be able to deduce return type from return statement: returnType is optional if no parameters, parentheses are optional example: []{cout << ”Hello, World!” << endl;} can be assigned to function pointer variables –watch out for implicit captures can be used as parameters for other functions, have to conform to signature 5

count_if, generate, for_each count_if – counts number of elements that satisfy callback condition int num=55; int cnt = count_if(vect.begin(), vect.end(), [num](int i){return i==num;}); generate – fills elements with value returned by callback generate(vect.begin(), vect.end(), []{return rand()%10;}); for_each – executes callback for each element for_each(vect.begin(), vect.end(), [](int i){cout << i << " ";}); 6

accumulate with various callbacks accumulates data about container two forms accumulate(beginRange, endRange, initialValue) – sums elements, sum initialized to initialValue, returns accumulated value accumulate(beginRange, endRange, initialValue, callback) invokes callback with two arguments, first is accumulator callback can be function or lambda int product(int num1, int num2){ return num1 * num2; } double mult = accumulate(vect.begin(), vect.end(), 1, product); or double multLambda = accumulate(vect.begin(), vect.end(), 1, [](int num1, int num2){return num1 * num2;}); 7

Function Objects (Functors) can overload function call operator: operator() in a class –such class is functor –may have any number of arguments and return any value then invoke like a standalone function class MyFunctor{ public: MyFunctor(int x) : x_(x) {} int operator() (int y) {return x_+y;} private: int x_; }; … MyFunctor addOne(1); // creating a functor object cout << addOne(2) << endl; // call it like a regular function may keep state between calls. Do not use this feature for algorithms! for simple tasks lambda functions are preferred 8

Predefined Functors, Arithmetic STL provides a number of predefined functors defined in in std namespace (need to be imported or scope resolved) arithmetic: plus, minus, multiplies, divides, modulus have to be instantiated with type plus myPlus; int result = myPlus(3,4); cut << result << endl; may be used in algorithms as callbacks int sum = accumulate(vect.begin(), vect.end(), 0, plus ()); regular operators cannot be used as callbacks, functors are adapters that wrap regular arithmetic operators 9

Comparison and Logical Functors comparison functors: equal_to not_equal_to less greater less_equal greater_equal –less is used as default comparison in priority_queue container adapter –may be changed, have to specify container, usually vector –example: reversing sorting order in priority_queue priority_queue, std::greater > workWeekR; logical functors: logical_and logical_or logical_not –example: logical_and in accumulate to determine if all boolean elements are true vector flags; … bool allTrue=accumulate(flags.begin(), flags.end(), true, std::logical_and ()); 10

Functor Adapters (Binders) binder (function adapter) – a specialized function that creates a function by assigning (binding) a value of parameter of another function bind() a C++11 feature – most flexible binder newFunctior bind(oldFunctor, arguments) where –newFunctor – pointer to new functor with bound parameters –oldFunctor – old functor –arguments – arguments to old functor free specified as _1 _2, etc defined in std::placeholders namespace bound auto is useful as return type or it gets complicated examples auto f1 = bind(myFunc, _1, str); // binds second parameter to string str auto f2 = bind(myFunc, _2, _1); // swaps parameters 11

Using Binders to Form Callbacks binders useful in forming callbacks for algorithims inline using namespace std::placeholders; bool passingScore(int s, int threshold){ return s>=threshold; }... // biding second argument of function passingScore to 70 auto it=find_if(vect.begin(), vect.end(), bind(passingScore, _1, 70)); // binding second argument of standard functor greater_equal auto it = find_if(vect.begin(), vect.end(), bind(std::greater_equal (), _1, 70)); this example is probably easier to read with lambda, how would you implement it? 12

Containers of Objects algorithms perform on non-basic types correctly provided that proper operators are defined –e.g. operator< for sorting, operator== for searching common task: invoke a method on each object –suppose myclass declares myfunc() method and container cont holds elements of myclass may be accomplished as follows for_each(cont.begin(), cont.end(), &myclass::myfunc); –if need to pass parameters, use bind() for_each(cont.begin, cont.end(), bind(&myclass::myfunc, _1, value)); 13

Algorithm Categories utility – not operating on containers but useful non-modifying – not updating the container –search: min_element, max_element, find_fist_of, search, search_n –comparison: equal, mismatch, liexicographical_compare –operational: for_each –numerical processing: count, count_if, accumulate modifying – updating the container sorting – sorting or (dis)ordering container set – set functions 14

Utility Algorithms min, max, minmax, swap operate on a couple of elements use operator< use function templates examples int x=1,y=2; cout << min(x, y); // prints1 cout << max(x, y); // prints 2 swap(x, y); cout<< x << y; // prints 21 auto pair = minmax(x,y); cout << pair.first << pair.second; // prints 12 In C++11, utility algorithms operate on initializer lists: max({1,2,3,4,5}); 15

Search Algorithms return iterator to first element found accept range by default use opeator== or operator< find, find_if, find_if_not – already covered min_element, max_elment – locate element auto it=min_element(vect.begin(), vect.end()); adjacent_find – finds the first pair of matching consecutive elements find_first_of – finds first occurrence of elements in target range search – finds target subsequence search_n – finds consecutive elements searches that work on ordered sequences (sorted vector, map, multimap, set, multiset ): binary_search, lower_bound, upper_bound, equal_range C++11 functions: find_if_not, minmax_element, all_of, any_of, none_of 16

Comparison and Operational comparison – compare entire ranges of elements equal() – returns true if elements in both ranges are equal mismatch() returns iterator to the first mismatched element lexicographical_compare() – dictionary order comparison of elements operational for_each() – executes callback on each element of the range: may print a copy of every element, accumulate info about all elements, etc. 17

Modifying Algorithms usually operate on two ranges: source range and destination (target) range, ranges may be independent, overlapping or the same (in place operation) transform() – similar to for_each() expects callback to return a value to be stored in the target range –variant: has two source ranges, callback accepts two parameters – one for each source range and stores value for the target range. Can be used to process two containers copy() – copies source to target range copy_if() – copies if callback returns true C++11 –returns iterator past the last element copied – can be used to trim unused after copy elements replace() – replaces elements with particular value with a different one replace_if() – replaces by new value if callback returns true reverse() – reverses elements in container move() – moving elements with C++11 move semantics, leaves source elements in unspecified by valid state unique() – eliminates consequent duplicates – useful with sorted containers 18

Remove (and Erase) remove() – removes elements with specific value remove_if() – removes if callback returns true both modifying algorithms do not erase elements from containers (do not know if whole or full range) –instead move remaining elements forward –return iterator past last remaining elements remove-erase-idiom – get the returned iterator and then use the container’s erase() function to eliminate removed elements –can be done in single line removes are linear –preferred to iterative erase() invocation – for random access containers memory reorganization to keep continuous, results in quadratic complexity 19

Sorting sort() – n log(n) sort of the range merge() – linear merge of source ranges –target range has to be large enough –does not return iterator; no elements are removed – number of elements in target container is sum of source sizes: use resize() or erase() to trim target unique() – eliminates duplicates, returns iterator past the last element binary_search() – log(n) search in sorted container for a value, returns true if found –lower_bound() is same complexity but more useful random_shuffle() – reshuffles range in linear time, internally uses rand() 20

Set operate on sorted containers with unique elements, not necessarily sets; in fact, sequential containers are recommended includes() – returns true if first range includes second set_union() – computes union (duplicates eliminated) from two source ranges, puts it in destination range, returns pointer past last element set_intersection() – computes intersection of two source ranges set_difference() – difference (complement) of first range with second – elements of first range that are not present in the second set_symmetric_difference() – elements of first range that are not present in second and v.v. 21