元编程的C ++ STL功能等效项

Question

Are there constexpr or other compile time equivalents to the STL functional and other libraries for use with metaprogramming? More specifically, I am trying to write some metaprograms that use SFINAE to evaluate some conditional and generate the corresponding types. Example:

template<int A, int B>
enable_if_t<(A < B)> my_func() {// do something 
}

template<int A, int B>
enable_if_t<!(A < B)> my_func() {// do nothing 
}

Ideally I would like the user to be able to pass in a comparator (like std::less<int> ), rather than hard coding it to < . So something like:

template<int A, int B, class comp = std::less<int>>
enable_if_t<comp(A, B)> my_func() {// do something 
}

template<int A, int B, class comp = std::less<int>>
enable_if_t<comp(A, B)> my_func() {// do nothing 
}

However since the functional objects are not constant expressions, they are not getting evaluated at compile time and so this does not work. What would be the right way to implement something like this?

Answer 1

std::less<int>(int, int) is not a constructor for std::less . The only constructor for std::less is () (I prefer using {} , because it makes it clear I'm constructing something).

Since C++14 it has a constexpr operator() that (if < on the types involved is constexpr ) can be evaluated at compile time.

Thus:

template<int A, int B, class comp = std::less<int>>
enable_if_t<comp{}(A, B)> my_func() {// do something 
}

template<int A, int B, class comp = std::less<int>>
enable_if_t<!comp{}(A, B)> my_func() {// do nothing 
}

should work.

In C++11

namespace notstd {
  template<class T=void>
  struct less {
    constexpr bool operator()(T const& lhs, T const& rhs)const{
      return lhs<rhs;
    }
  };
  template<>
  struct less<void> {
    template<class T, class U>
    constexpr bool operator()(T const& lhs, U const& rhs)const{
      return lhs<rhs;
    }
    // maybe also add this:
    //struct is_transparent {};
  }
}

(assuming your < on your system is a total order on pointers) should work (replacing std::less<T> with notstd::less<T> ).