generalized sorting function and using binary_function

Question

template<class T>
struct gSorting : public std::binary_function<T, T,bool> {
  bool operator() (int number, int n2)              
  {
    cout << "int" << endl;
    return (number<n2);
  }
  bool operator() (double number, double n2)        
  {
    cout << "double" << endl;
    return (number<n2);
  }
  bool operator() (const MYClass& obj1, const MYClass& obj2)        
  {
    return (obj1.element<obj2.element);
  }
};

int main () {
  gSorting<int> sorting_object;

  std::cout << std::boolalpha << sorting_object (2.0f, 4.3f) << ".\n";
  std::getchar();
  return 0;
}

is there any problem with this code? is it that generic? or is there better way to do a generic sorting algorithm to include all of my classes used

it compiles, the output pointed to the double which is good, however how can I make it a template, but dont have to specify the input type in the declaration?

gSorting< int > sorting_object;

-------------^^^^ we dont need any specific type? am I right

output:

Answer 1

I would personally define a class template for the binary predicate and specialize it as needed, e.g.:

template <typename T>
struct gSorting
    : std::binary_function<T const&, T const&, bool> // not really needed
{
    bool operator()(T const& t0, T const& t1) const {
        return t0 < t1;
    }
};
template <>
struct gSorting<MyClass>
    : std::binary_function<MyClass const&, MyClass const&, bool>
{
    bool operator()(MyClass const& c0, MyClass const& c1) const {
        return c0.element < c1.element;
    }
};

In a real implementation, the argument type for the generic version should probably decide whether the argument is passed by value or by const& depending on the kind of type and/or based on a trait which is then specialized as needed. For example:

template <typename T>
struct argument_type
{
    typedef typename std::conditional<
        std::is_fundamental<T>::value, T, T const&>::type type;
};

template <typename T>
struct gSorting
    : std::binary_function<typename argument_type<T>::type,
                           typename argument_type<T>::type, bool>
{
    typedef typename argument_type<T>::type arg_type;
    bool operator()(arg_type t0, arg_type t1) const {
        return t0 < t1;
    }
};