Member variable comparator factory

  Assume you have some kind of struct with several member variables. For
the same of simplicity, let's assume that your struct is like:

struct Info
{
    str::string name;
    int age;
};

  Now, suppose you have, for example, a vector of objects of type Info,
and you would like to be able to sort the vector either by name or by age.
Bummer, you'll have to write two comparators for this. However, wouldn't
it be nice if you could just do something like this:

    // Sort the array by name:
    std::sort(array.begin(), array.end(),
              makeMemberComparator(&Info::name);

or

    // Sort the array by age:
    std::sort(array.begin(), array.end(),
              makeMemberComparator(&Info::age);

  That way you wouldn't have to write a new comparator function every time
you need to sort by some member variable of some struct.

  Well, it is very possible to implement a 'makeMemberComparator()' like
above. It happens like this:

//--------------------------------------------------------------------
template<typename Object_t, typename Var_t>
class MemberVarComparator
{
    typedef const Var_t Object_t::*MemberVarPtr_t;
    MemberVarPtr_t memberVarPtr;

 public:
    MemberVarComparator(MemberVarPtr_t ptr): memberVarPtr(ptr) {}

    bool operator()(const Object_t& obj1, const Object_t& obj2) const
    {
        return obj1.*memberVarPtr < obj2.*memberVarPtr;
    }
};

template<typename Object_t, typename Var_t>
MemberVarComparator<Object_t, Var_t>
makeMemberComparator(const Var_t Object_t::*memberVarPtr)
{
    return MemberVarComparator<Object_t, Var_t>(memberVarPtr);
}
//--------------------------------------------------------------------

  Of course this will always sort using operator<. I'll leave it as an
exercise to enhance the class and the makeMemberComparator() function to
support specifying the comparison type (such as eg. std::greater), the
default being, naturally, std::less.