Question

I was just reading this

class biggerThan 
      {
        public:
        const int testValue;
        biggerThan(int x) : testValue(x) { }

        bool operator()(int val) const 
        { return val > testValue; }
  };

Now say its used like

  std::list<int>::iterator firstBig =
     std::find_if(aList.begin(), aList.end(), biggerThan(12));

OR

Just simply like this
biggerThan object(12)

Now when biggerThan(12) this is used it can invoke the constrcutor to initialze the testvalue or () operator is overloaded and 12 is passed to the function(bool operator()(int val) const ) so that it returns a bool.

which one happens first/how does it works

does it leads to any ambiguity or does the call to the overlaode operator happens in some fashion like

object.operator().(12).

please make my undersatnding clear.

Answer 1

Maybe the following code will make it clear:

#include <iostream>
#include <algorithm>

class biggerThan 
      {
        public:
        const int testValue;
        biggerThan(int x) : testValue(x) { 
            std::cout << "Construction of biggerThan object with value " 
                      << x << std::endl;
        }

        bool operator()(int val) const 
        { 
            if (val > testValue) {
                std::cout << val << " is bigger than " << testValue 
                          << std::endl;
                return true;
            }
            else {
                std::cout << val << " is *not* bigger than " << testValue 
                          << std::endl;
                return false;
            }
        }
};

int main() {
    int data[] = {0,1,2,3,4,5,6,7,8,9};
    std::for_each(data, data+10, biggerThan(4));
}    

The output is:

Construction of biggerThan object with value 4
0 is *not* bigger than 4
1 is *not* bigger than 4
2 is *not* bigger than 4
3 is *not* bigger than 4
4 is *not* bigger than 4
5 is bigger than 4
6 is bigger than 4
7 is bigger than 4
8 is bigger than 4
9 is bigger than 4

What happens:

1. The last argument to std::for_each is an object of type biggerThan, that is constructed with the argument 4.
2. The operator()(int) of this biggerThan-object (actually a copy of it) is invoked for every element in data.

The algorithm you use (std::find_if) works the same in this regard.