Function Objects

• Function objects take the place of function pointers in traditional C programming.

• They work by overloading operator().

• Example:

    #include < iostream.h >
  
    template < class T >
    struct square {
      T operator()(T n) {return n*n;}
      };
  
    template < class T, class funcObj >
    void printEval(T val,funcObj f) {
      cout << f(val) << endl;
      };
  
    main() {
      printEval(1.4, square < float > ());
      printEval(1.4, square < int > ());
      return 0;
      }
    

  output:

  
    1.96
    1
    

• Very useful for generating needed functions on-the-fly. (Can't use template functions for this since we can't specify the template arguments.)

• Also useful when functions need to encapsulate data:

    template < class T >
    struct sum_square {
      T & counter;
      sum_square(int &c): counter(c) {counter=0;}
      T operator()(T n) {
        T temp = n*n;
        counter += temp;
        return temp;
        }
      };
    ...
    int test[20]
    ...
    ostream_iterator < int > output (cout," ");
    ...
    int sum;
    transform(test,test+20,output,sum_square < int > (sum));
    cout << "Sum of squares = " << sum;
    

• Function adaptors take function objects and mutate their application. For example:

  template < class Operation1, class Operation2, class Operation3 >
  class binary_compose : public unary_function< Operation2::argument_type,
                                               Operation1::result_type > {
  protected:
      Operation1 op1;
      Operation2 op2;
      Operation3 op3;
  public:
      binary_compose(const Operation1& x, const Operation2& y, 
  		   const Operation3& z) : op1(x), op2(y), op3(z) { }
      result_type operator()(const argument_type& x) const {
  	return op1(op2(x), op3(x));
      }
  };
  
  compose2(const Operation1& op1, const Operation2& op2, const Operation3& op3) {
      return binary_compose(op1, op2, op3);
  }
  

  Example use:

  //outi == ai2 + 2ai
  transform(a.begin(),a.end(),out,
     compose2(add< int >(),
              square< int >(),
              bind1st(mult< int >(),2)));
  

• See also [Laufer95] for an interesting treatment of function binding and composition.