Why is std::less a class template?

Question

According to 20.8.5 §1, std::less is a class template with a member function:

template<typename T>
struct less
{
    bool operator()(const T& x, const T& y) const;
    // ...
};

Which means I have to mention the type when I instantiate the template, for example std::less<int>. Why isn't std::less a normal class with a member function template instead?

struct less
{
    template<typename T, typename U>
    bool operator()(const T& x, const U& y) const;
    // ...
};

Then I could simply pass std::less to an algorithm without the type argument, which can get hairy.

Is this just for historic reasons, because early compilers (supposedly) did not support member function templates very well (or maybe even at all), or is there something more profound to it?

`std::string a; std::less()(a, "HI");` (see `std::lower_bound`) — Mooing Duck, Dec 13 '12 at 20:33
C++14 will include a specialization to make `std::less<>()` perfectly-forwarding. See [N3421](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3421.htm), which (I believe) was adopted in Portland without modification. — James McNellis, Dec 13 '12 at 20:35
@MooingDuck `std::less()(a, "HI")` is `true` on my system, is that a problem? — fredoverflow, Dec 13 '12 at 20:36
@FredOverflow: Wait, shouldn't it have had a type deduction failure? Oh, you modified so that doesn't require them to be the same. — Mooing Duck, Dec 13 '12 at 20:37

Charles Salvia · Accepted Answer · 2012-12-13T21:31:08.510

It's so that the class created by the instantiated template has nested typedefs which provide type information about the result type and argument types of the functor:

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

  template <class T> 
  struct less : binary_function <T,T,bool> 
  {
    bool operator() (const T& x, const T& y) const;
  };

std::less inherits from std::binary_function, which produces these typedefs. So for example, you can extract the result type using std::less<T>::result_type.

Nowadays, this is mostly unnecessary with C++11's decltype and auto keywords.

Those member types were completely removed in C++20 https://en.cppreference.com/w/cpp/utility/functional/less — Adam.Er8, Sep 23 '20 at 12:52

score 9 · Answer 2 · answered Dec 13 '12 at 20:36

9

That's the way we did it back in C++98. Now that we understand templates and forwarding better (with 14 years more experience), newer function types do what you said: the function call operator is a template function.

answered Dec 13 '12 at 20:36

Pete Becker

74,985
8
76
165

score 1 · Answer 3 · answered Dec 13 '12 at 21:53

The proposal by Stephan to change this so that all such function objects are polymorphic in their operator() was accepted at the previous meeting, is my understanding.

So the answer to your question "why is the function call operator not templated?", is that it is.

Why is std::less a class template?

3 Answers3