SFINAE: static_assert vs std::enable_if

Question

Are there any disadvantages in the following (suggested!) syntax?

template< typename T > void f() static_assert(std::is_same< T, int >::value) { ; } 

instead of SFINAE (that looks like a crutch):

template< typename T, typename = typename std::enable_if< std::is_same< T, int >::value >::type > void f() { ; } 

or even worse:

template< typename T > typename std::enable_if< std::is_same< T, int >::value >::type  f()  { ; } 

which prohibits using of auto deduction of result type.

Answer 1

First of all, those are different, specifically they are not checked at the same time.

The critical difference is due to their application with regard to overload resolution. SFINAE will cull functions from the overload set, so that another function gets chosen (if any) whereas static_assert is applied after overload resolution and thus will give an error that will stop compilation.

Now, regarding your complaint, you can perfectly use auto and SFINAE:

// Ensure that T is int template <typename T> auto f() -> typename std::enable_if< std::is_same< T, int >::value >::type { ... }  // Only pick this overload if begin(c) and end(c) are available template <typename T> auto f(T const& c) -> decltype(begin(c), end(c), bool{}) { ... } 

... and you can perfectly use SFINAE and automatic type deduction

template <typename T,           typename = typename std::enable_if<std::is_same<T, int>::value>::type> auto f() { ... }  template <typename T> auto f(void* =        typename std::enable_if<std::is_same<T, int>::value>::type*(0)) { ... } 

Answer 2

Why would using static_assert be better than the Concepts Lite syntax?

template< typename T >   void f() requires Int<T>()   { } 

or:

template< Int T >   void f()   { }