Functors in Standard Library

I have been programming with the STL for a while now and I have a question about using functors. Look at this code

Code:

---

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct plus : public binary_function<int, int, int> {
  int operator() (int x, int y) { return x + y; }
};

void my_print(int x) {
  cout << x << endl;
}

int main(void)
{
  vector<int> v(5);
  vector<int> w(5);
  vector<int> x(5);
  fill(v.begin(),v.end(), 5);
  fill(w.begin(),w.end(), 1);
  transform(v.begin(),v.end(), w.begin(), x.begin(), ::plus());
  for_each(x.begin(), x.end(), my_print);
  return 0;
}

---

Note how I use :: plus which is an object that overrides () and then I use my_print which is a function. I understand that they both do the same thing (:: plus() calls overloaded () operator and my_print is a function pointer) I was wondering why the STL uses classes and inheritance (i.e. inheriting from binary_function<arg1,arg2, retval>). Is this so you can store more information in a function like member variables? Also, is there any difference in performance between the two ways I used STL functions?

binary_function looks simply like this:

Code:

---

template<class Arg1, class Arg2, class Result>
    struct binary_function {
    typedef Arg1 first_argument_type;
    typedef Arg2 second_argument_type;
    typedef Result result_type;
    };

---

By inheriting from that you make these typedefs available for your functor. These are used in some places: given a functor how would you determine what its return type is?

Code:

---

template <class Container, class Predicate>
void foo(const Container& c, Predicate p)
{
    //how do I know what types it takes and what type it returns?
    typename Predicate::result_type result = p(c[0], c[1]);
}

---

It's not necessary always but sometimes it might be useful.

Same applies for writing your own iterators.

Quote:

---

Originally Posted by linuxdude

Is this so you can store more information in a function like member variables?

---

No. Any predicates you pass to STL containers/algorithms must be stateless, otherwise the behavior could be undefined.
See: Chapter 87. Make predicates pure functions

Quote:

---

Originally Posted by cpjust

No. Any predicates you pass to STL containers/algorithms must be stateless, otherwise the behavior could be undefined.
See: Chapter 87. Make predicates pure functions

---

Being "stateless" in this case just means that it always returns the same output for the same input. If the functor adheres to that, it can certainly take into account the values of some member variables.

For instance, say you are using std::transform() to multiply all the elements of a vector by 2.7. You create a Multiply functor class, and construct it with an initializer of 2.7 which tells it what it needs to multiply by.

The link cpjust provides is simply saying that this internal state should never change, i.e. if you pass value X to the functor and get result Y, then you should ALWAYS get result Y when you pass value X. That does not mean that the result can't depend on some state carried inside the functor.

it is good practice to do this. Mostly to make your functors adaptable for use with std::bind1st, std::not1 and all the otrher adapters.

See "Adaptable functions" here:

http://www.builderau.com.au/program/...0278834,00.htm

but scott meyers explains it better in:
Effective STL: 50 Specific Ways to Improve the Use of the Standard Template Library Addison-Wesley Professional Computing Series: Amazon.co.uk: Scott Meyers: Books

Thanks for the information. These responses confirmed my thoughts. The "effective" books are so darn...effective. I don't have that one though. I'll have to look into it.