predicate function exa c++

Functions as Algorithm Arguments

To increase their flexibility and power, several algorithms allow the passing of user-defined auxiliary functions. These functions are called internally by the algorithms.

Examples of Using Functions as Algorithm Arguments

The simplest example is the for_each() algorithm. It calls a user-defined function for each element of the specified range. Consider the following example:

#include <iostream> #include <vector> #include <algorithm> using namespace std; //function that prints the passed argument void print (int elem) { cout << elem << ' ' ; } int main() { vector<int> coll; //insert elements from 1 to 9 for (int i=1; i<=9; ++i) { coll.push_back(i); } //print all elements for_each (coll.begin(), coll.end(), //range print); //operation cout << endl; }

The for_each() algorithm calls the passed print() function for every element in the range [coll.begin(),coll.end()). Thus, the output of the program is as follows:

1 2 3 4 5 6 7 8 9

Algorithms use auxiliary functions in several variants—some optional, some mandatory. In particular, you can use them to specify a search criterion, a sorting criterion, or to define a manipulation while transferring elements from one collection to another.

Here is another example program:

#include <iostream> #include <vector> #include <set> #include <algorithm> #include "print.hpp" int square (int value) { return value*value; } int main() { std::set<int> coll1; std::vector<int> coll2; //insert elements from 1 to 9 into coll1 for (int i=1; i<=9; ++i) { coll1.insert(i); } PRINT_ELEMENTS(coll1,"initialized: "); //transform each element from coll1 to coll2 // - square transformed values std::transform (coll1.begin(),coll1.end(), //source std::back_inserter(coll2), //destination square); //operation PRINT_ELEMENTS(coll2,"squared: "); }

In this example, square() is used to square each element of coll1 while it is transformed to coll2 (see figure below). The program has the following output:

Figure : How transform () operates

initialized: 1 2 3 4 5 6 7 8 9 squared: 1 4 9 16 25 36 49 64 81

Predicates

A special kind of auxiliary function for algorithms is a predicate. Predicates are functions that return a Boolean value. They are often used to specify a sorting or a search criterion. Depending on their purpose, predicates are unary or binary. Note that not every unary or binary function that returns a Boolean value is a valid predicate. The STL requires that predicates always yield the same result for the same value. This rules out functions that modify their internal state when they are called.

Unary Predicates

Unary predicates check a specific property of a single argument. A typical example is a function that is used as a search criterion to find the first prime number:

#include <iostream> #include <list> #include <algorithm> #include <cstdlib> //for abs() using namespace std; //predicate, which returns whether an integer is a prime number bool isPrime (int number) { //ignore negative sign number = abs(number); // 0 and 1 are prime numbers if (number == 0 || number == 1) { return true; } //find divisor that divides without a remainder int divisor; for (divisor = number/2; number%divisor != 0; --divisor) { ; } //if no divisor greater than 1 is found, it is a prime number return divisor == 1; } int main() { list<int> coll; //insert elements from 24 to 30 for (int i=24; i<=30; ++i) { coll.push_back(i); } //search for prime number list<int>::iterator pos; pos = find_if (coll.begin(), coll.end(), //range is Prime); //predicate if (pos != coll.end()) { //found cout << *pos << " is first prime number found" << endl; } else { //not found cout << "no prime number found" << endl; } }

In this example, the find_if() algorithm is used to search for the first element of the given range for which the passed unary predicate yields true. Here, the predicate is the isPrime() function. This function checks whether a number is a prime number. By using it, the algorithm returns the first prime number in the given range. If the algorithm does not find any element that matches the predicate, it returns the end of the range (its second argument). This is checked after the call. The collection in this example has a prime number between 24 and 30. So the output of the program is as follows:

29 is first prime number found

Binary Predicates

Binary predicates typically compare a specific property of two arguments. For example, to sort elements according to your own criterion you could provide it as a simple predicate function. This might be necessary because the elements do not provide operator < or because you wish to use a different criterion.

The following example sorts elements of a set by the first name and last name of a person:

#include <iostream> #include <string> #include <deque> #include <algorithm> using namespace std; class Person { public: string firstname() const; string lastname() const; ... }; /*binary function predicate: *- returns whether a person is less than another person */ bool personSortCriterion (const Person& p1, const Person& p2) { /*a person is less than another person *- if the last name is less *- if the last name is equal and the first name is less */ return p1.lastname()<p2.1astname() || (!(p2.1astname()<p1.lastname()) && p1.firstname()<p2.firstname()); } int main() { deque<Person> coll; ... sort (coll. begin(), coll. end() , //range personSortCriterion); //sort criterion ... }

Note that you can also implement a sorting criterion as a function object. This kind of implementation has the advantage that the criterion is a type, which you could use, for example, to declare sets that use this criterion for sorting its elements.

-----------------------------------------------------------------
See Also:
-----------------------------------------------------------------

• Complete Tutorial of C++ Template's
• Standard Template Library Tutorial
• Inter Process Communication Tutorial
• Advance Programming in C & C++

-----------------------------------------------------------------

The Art of Learning with Innovation,
eLearning Courses for C and C++ Programming Language - The Most appreciated course !!!

Copyright © ccplusplus.com