Re: Point of operator() overloading (no pun intended)

"Stick" <Stick@discussions.microsoft.com> wrote in message
news:6429B63C-3FE5-4B6A-81DB-B94836C841AC@microsoft.com


Overloading operator() makes sense for function-like objects, aka
functors. For example, consider std::copy_if function that would look
something like this:

template <typename InIter, typename OutIter, typename Predicate>
OutIter copy_if(InIter first, InIter last, OutIter out, Predicate pr) {
    while (first != last) {
        if (pr(*first)) {
            *out++ = *first;
        }
        ++first;
    }
}

This function copies all elements from input range that meet a certain
condition into the output range. For example, you can use it to copy all
positive elements from one array into another:

int in[5] = {1, -2, 3, -4, 5};
int out[5];

bool isPositive(int x) {return x > 0};

copy_if(in, in + 5, out, isPositive);

Now imagine that you want to copy all elements greater than some
threshold value t, determined at run-time. The implementation of copy_if
does not allow you to use a function that takes an extra parameter. But
actually, copy_if does not require that Predicate be a function: it can
be anything you can apply a fuinction call operator to, in particular a
class overloading operator(). And such a class can be stateful
(something that is pretty difficult to arrange for a simple function).
Consider:

template <typename T>
class IsAboveThreshold {
  public:
    IsAboveThreshold(const T& t) : t_(t) {}
    bool operator()(const T& x) const {return x > t_;}
  private:
    T t_;
};

// copy all elements greater than 2
copy_if(in, in+5, out, IsAboveThreshold(2) );

--
With best wishes,
    Igor Tandetnik

With sufficient thrust, pigs fly just fine. However, this is not
necessarily a good idea. It is hard to be sure where they are going to
land, and it could be dangerous sitting under them as they fly
overhead. -- RFC 1925