Detect operator support with decltype/SFINAE

by

In C++11 the shortest most general solution I found was this one:

#include <type_traits>

template<class T, class = decltype(std::declval<T>() < std::declval<T>() )> 
std::true_type  supports_less_than_test(const T&);
std::false_type supports_less_than_test(...);

template<class T> using supports_less_than = decltype(supports_less_than_test(std::declval<T>()));

#include<iostream>
struct random_type{};
int main(){
    std::cout << supports_less_than<double>::value << std::endl; // prints '1'
    std::cout << supports_less_than<int>::value << std::endl; // prints '1'
    std::cout << supports_less_than<random_type>::value << std::endl; // prints '0'
}

Works with g++ 4.8.1 and clang++ 3.3

A more general solution for arbitrary operators (UPDATE 2014)

There is a more general solution that exploits the fact that all built-in operators are also accessible (and posibly specialized) through STD operator wrappers, such as std::less (binary) or std::negate (unary). 

template<class F, class... T, typename = decltype(std::declval<F>()(std::declval<T>()...))> 
std::true_type  supports_test(const F&, const T&...);
std::false_type supports_test(...);

template<class> struct supports;
template<class F, class... T> struct supports<F(T...)> 
: decltype(supports_test(std::declval<F>(), std::declval<T>()...)){};

This can be used in a quite general way, especially in C++14, where type deduction is delayed to the operator wrapper call (“transparent operators”).

For binary operators it can be used as: 

#include<iostream>
struct random_type{};
int main(){
    std::cout << supports<std::less<>(double, double)>::value << std::endl; // '1'
    std::cout << supports<std::less<>(int, int)>::value << std::endl; // '1'
    std::cout << supports<std::less<>(random_type, random_type)>::value << std::endl; // '0'
}

For unary operators:

#include<iostream>
struct random_type{};
int main(){
    std::cout << supports<std::negate<>(double)>::value << std::endl; // '1'
    std::cout << supports<std::negate<>(int)>::value << std::endl; // '1'
    std::cout << supports<std::negate<>(random_type)>::value << std::endl; // '0'
}

(With the C++11 standard library is a bit more complicated because there is no failure on instatiating decltype(std::less<random_type>()(...)) even if there is no operation defined for random_type, one can implement manually transparent operators in C++11, that are standard in C++14)

The syntax is quite smooth. I hope something like this is adopted in the standard.

Two extensions:

1) It works to detect raw-function applications: 

struct random_type{};
random_type fun(random_type x){return x;}
int main(){
    std::cout << supports<decltype(&fun)(double)>::value << std::endl; // '0'
    std::cout << supports<decltype(&fun)(int)>::value << std::endl; // '0'
    std::cout << supports<decltype(&fun)(random_type)>::value << std::endl; // '1'
}

2) It can additionally detect if the result is convertible/comparable to a certain type, in this case double < double is supported but a compile-time false will be returned because the result is not the specified one.

std::cout << supports<std::equal_to<>(std::result_of<std::less<>(double, double)>::type, random_type)>::value << std::endl; // '0'

Note: I just tried to compile the code with C++14 in http://melpon.org/wandbox/ and it didn’t work. I think there is a problem with transparent operators (like std::less<>) in that implementation (clang++ 3.5 c++14), since when I implement my own less<> with automatic deduction it works well.

More Related Contents:

  1. What is decltype with two arguments?
  2. Check if a class has a member function of a given signature
  3. Why do constant expressions have an exclusion for undefined behavior?
  4. SFINAE working in return type but not as template parameter
  5. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  6. What is “Expression SFINAE”?
  7. decltype and parentheses
  8. trailing return type using decltype with a variadic template function
  9. Selecting a member function using different enable_if conditions
  10. Why doesn’t SFINAE (enable_if) work for member functions of a class template?
  11. Why should I avoid std::enable_if in function signatures
  12. Arrow operator (->) in function heading
  13. Detecting constexpr with SFINAE
  14. Significance of parentheses in decltype((c))?
  15. Template specialization and enable_if problems [duplicate]
  16. SFINAE works differently in cases of type and non-type template parameters
  17. How to use sfinae for selecting constructors?
  18. decltype as a return type in class member function
  19. Difference between std::result_of and decltype
  20. What does the void() in decltype(void()) mean exactly?
  21. What expressions yield a reference type when decltype is applied to them?
  22. using SFINAE for template class specialisation
  23. Assert that code does NOT compile
  24. Is substitution performed on a variadic parameter pack type if the pack is empty?
  25. “What happened to my SFINAE” redux: conditional template class members?
  26. Does moving leave the object in a usable state?
  27. Copy constructor is not inherited
  28. C++11 lambda implementation and memory model
  29. C++11: Compile Time Calculation of Array
  30. What’s the standard/official name for universal references?

Leave a Comment