Functor that calls a function after dereferencing?

Is there a small functor in the C++ st开发者_开发技巧andard or in Boost that wraps around another functor, but dereferences a pointer before it calls that functor?

I'm thinking of something like this:

template<class F>
struct DerefCmp {
  template<class T>
  bool operator()(T* v) const {
    return F(*v);
  }
};

I'd use it in a container of pointers, for example, where I want to compare by value:

std::set<int*, DerefCmp< std::equal<int> > > s;

I am not aware of any function object in the C++ Standard Library or in Boost that does this (that's not to say there isn't one; I am not familiar with everything in the Boost libraries :-P).

However, writing your own is rather straightforward. Consider the following:

template <typename Predicate>
class indirect_binary_predicate
{
public:
    indirect_binary_predicate(const Predicate& pred = Predicate()) 
        : pred_(pred) 
    {
    }

    template <typename Argument0, typename Argument1>
    bool operator()(Argument0 arg0, Argument1 arg1) const 
    { 
        return pred_(*arg0, *arg1); 
    }

private:
    Predicate pred_;
};

Usage example:

std::set<int*, indirect_binary_predicate<std::equal_to<int> > > s;

Note that it is ill-advised to have a container of raw pointers if the pointers are to dynamically allocated objects and the container has ownership of the pointed-to objects; it isn't exception-safe to do this. That said, this predicate adapter should work just as well for smart pointers, iterators, or any other type that supports dereferencing.

You may look at the boost pointer containers. They can be used for this purpose with the standard functors: Boost.PointerContainer