function objects and constructors

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.

… What?

Konrad Rudolph
– Konrad Rudolph

2011-05-25 08:28:37 +00:00
Commented May 25, 2011 at 8:28 — Konrad Rudolph
– Konrad Rudolph, Commented May 25, 2011 at 8:28

Community · Accepted Answer · 2020-06-20 09:12:55Z

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:

The last argument to std::for_each is an object of type biggerThan, that is constructed with the argument 4.
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.

Michael Burr · Accepted Answer · 2011-05-25 08:31:31Z

2

when biggerThan(12) this is used it can invoke the constructor to initialize the testvalue

Yes. biggerThan(12) creates an instance of the biggerThan class with testvalue set to 12.

When std::find_if() calls the functor, it will call the operator()(int val) member function of that instance.

answered May 25, 2011 at 8:31

Michael Burr

342k52 gold badges553 silver badges774 bronze badges

Comments

Mayank · Accepted Answer · 2011-05-25 08:32:22Z

2

biggerThan(12) will pass an object of biggerThan at std::find_if(aList.begin(), aList.end(), biggerThan(12)); line;

To invoke operator() following is the way;

biggerThan obj(12); //This is a constructor call
biggerThan(13); //This is function operator call

@std::find_if(aList.begin(), aList.end(), biggerThan(12)); the third parameter that is passed will be temporary object of biggerThan initialized with 12

answered May 25, 2011 at 8:32

Mayank

5,8389 gold badges40 silver badges60 bronze badges

3 Comments

munish Over a year ago

mayank, biggerThan obj(12); won't invake the operator right.....I am asking because i thought it would

Mayank Over a year ago

operator() or any other operator comes into picture when an object is created. The operator is called like a function for eg. obj.operator()(12). For this to happen, an object is required on which can invoke some operator/function

munish Over a year ago

hmm...so operator() is hidden usually while calling while the call actually like obj.operator()(12)....thanks

Kurt Krueckeberg · Accepted Answer · 2014-01-09 02:04:42Z

0

In general, you can accomplish the same thing using greater<> and bind2nd<>, which are in <functional>

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

bind2nd turns any binary function object, like greater<int> into a unary function object. In the case of greater<int> it effectively creates a function object whose less than operator looks like this

 bool operator>(const int& arg)
 {
    return functor.operator>(arg, 12); 
 }

where functor is greater<int>

edited Jan 9, 2014 at 2:04

answered Nov 1, 2012 at 20:50

Kurt Krueckeberg

1,25310 silver badges11 bronze badges

Collectives™ on Stack Overflow

function objects and constructors

4 Answers 4

Comments

Comments

3 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

Comments

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related