std::sort (begin, end, std::less<my_struct>);

D>std::sort (begin, end, std::less<my_struct>);
D>

struct my_struct_less
{
bool operator()( const my_struct& s1, const my_struct &s2)
   {
    // тут сравниваем как надо
   }
};

bool operator()( const my_struct& s1, const my_struct &s2) const

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

M>PS std::bind использую редко

template<typename T, typename Comp>
bool compare(T const& a, T const& b, Comp comp)
{
    return comp(a, b);
}

int main(int argc, char *argv[])
{
    std::cout << compare(1, 2, std::less<int>());
    return 0;
}

template <typename T>
struct my_comp1
{
  bool operator()(const T& arg1, const T& arg2) const
  {
    return (arg1 < arg2);
   }
};

template <typename R, typename T>
struct my_comp2
{
  typedef R result_type;

  result_type operator()(const T& arg1, const T& arg2) const
  {
    return (arg1 < arg2);
   }
};

void wmain()
{
  std::vector<int> v;
  v.push_back(2), v.push_back(1), v.push_back(3);

  //auto comporator1 = std::bind(my_comp1<int>(), std::placeholders::_1, std::placeholders::_2);
  auto comporator2 = std::bind(my_comp2<int, bool>(), std::placeholders::_1, std::placeholders::_2);
  //std::sort(std::begin(v), std::end(v), comporator1);
  std::sort(std::begin(v), std::end(v), comporator2);
}

template<class T, class Pred = std::less<T>> class quicksort {
        static inline T* partition(T* from, T* back)
        {
                T* front  =  from;
                ++front;
                --back;
                while (front < back)
                {
                        while ((front < back) && Pred()(*front, *from)) ++front;
                        while ((front < back) && !Pred()(*back, *from)) --back;
                        std::swap(*front, *back);
                }

                if (Pred()(*from, *front)) --front;
                std::swap(*from, *front);
                return front;
        }

        static void __fastcall recurse(T* from, T* to)
        {
                if (from < to - 1)
                {
                        T* mid = partition(from, to);
                        recurse(from, mid);
                        recurse(mid + 1, to);
                }
        }


public:

        explicit quicksort(std::vector<T> &v)
        {
                const size_t l = v.size();
                if (l)
                {
                        T *p = &v.front();
                        recurse(p, p + l);
                }
        }
};


template<class V, class Pred> inline void QuickSortVector(V &v) {
        quicksort<V::value_type, Pred>((V &)v); }

template<class V> inline void QuickSortVector(V &v) {
        quicksort<V::value_type>((V &)v);
}

template <class Iterator>
void sort(Iterator first, Iterator last)
. . . *x < *y . . .

template <class Iterator, class Predicate>
void sort(Iterator first, Iterator last, Predicate p)
. . . p(*x, *y) . . .