Cuándo usar `static_assert` en lugar de SFINAE?

Question

He estado usando (y visto usado) static_assert para marcar los valores no deseados de los valores de los parámetros de la plantilla. Sin embargo, para todos los casos que encontré parece mejor y más elegante desactivar esos valores no deseados a través de SFINAE. Por ejemplo

template<typename T, 
     class = std::enable_if<std::is_floating_point<T>::value>::type> 
struct Foo { ... }; 

en lugar de

template<typename T> 
struct Foo { 
    static_assert(std::is_floating_point<T>::value, 
       "Foo<T>: T must be floating point :-("); 
    ... 
}; 

Así que mi pregunta: ¿cuándo se debe utilizar en lugar de static_assert SFINAE y por qué?

EDITAR

creo que lo que he aprendido hasta ahora es la siguiente

SFINAE es una herramienta versátil y poderosa pero potencialmente muy complicado que puede ser usado para muchas tareas, incluyendo resolución de sobrecarga de función (que algunos parecen considerar como su único propósito).

SFINAE se puede utilizar de una manera relativamente simple donde cada vez static_assert puede, excepto que aparece en la declaración (de una clase o función) en lugar de su definición (o es posible insertar a static_assert en, digamos, una declaración de reenvío de clase?). Eso hace que el código sea más literal y, por lo tanto, más claro. Sin embargo, debido a que SFINAE es complicado, tiende a ser más difícil acertar que un simple static_assert.

Por otro lado, static_assert tiene la ventaja de un mensaje de error del compilador más claro, que algunos parecen considerar como el objetivo principal de cualquiera.

Answer 1

creo static_assert es el La elección correcta si desea hacer cumplir que T es un tipo de coma flotante. Este método expresa su intención más claramente que la solución SFINAE.

Answer 2

static_assert hace que la compilación falle. SFINAE le permite eliminar una posible sobrecarga.

Answer 3

Utiliza SFINAE, si desea utilizar otra sobrecarga, y static_assert si ninguno de ellos se ajusta a dicho parámetro.

Answer 4

Por un lado, usar SFINAE puede dar lugar a que se seleccione otra sobrecarga que originalmente era una peor coincidencia y que no se consideraría.

Y en la situación que hay otras sobrecargas, pero no de ellos es viable, se obtiene algunas cosas buenas como esta:

#include <type_traits> 

void f(int){} 
void f(bool){} 
void f(char){} 
void f(float){} 
void f(long){} 
void f(double){} 
void f(short){} 
void f(unsigned){} 
void f(void*){} 
void f(void (*)()){} 

template<class C, class T = int> 
using EnableIf = typename std::enable_if<C::value, T>::type; 

template<class T> 
struct sfinae_false : std::false_type{}; 

template<class T> 
void f(T&&, EnableIf<sfinae_false<T>> = 0){} 

int main(){ struct X{}; f(X()); } 

Salida:

source.cpp: In function 'int main()': 
source.cpp:23:30: error: no matching function for call to 'f(main()::X)' 
source.cpp:23:30: note: candidates are: 
source.cpp:3:6: note: void f(int) 
source.cpp:3:6: note: no known conversion for argument 1 from 'main()::X' to 'int' 
source.cpp:4:6: note: void f(bool) 
source.cpp:4:6: note: no known conversion for argument 1 from 'main()::X' to 'bool' 
source.cpp:5:6: note: void f(char) 
source.cpp:5:6: note: no known conversion for argument 1 from 'main()::X' to 'char' 
source.cpp:6:6: note: void f(float) 
source.cpp:6:6: note: no known conversion for argument 1 from 'main()::X' to 'float' 
source.cpp:7:6: note: void f(long int) 
source.cpp:7:6: note: no known conversion for argument 1 from 'main()::X' to 'long int' 
source.cpp:8:6: note: void f(double) 
source.cpp:8:6: note: no known conversion for argument 1 from 'main()::X' to 'double' 
source.cpp:9:6: note: void f(short int) 
source.cpp:9:6: note: no known conversion for argument 1 from 'main()::X' to 'short int' 
source.cpp:10:6: note: void f(unsigned int) 
source.cpp:10:6: note: no known conversion for argument 1 from 'main()::X' to 'unsigned int' 
source.cpp:11:6: note: void f(void*) 
source.cpp:11:6: note: no known conversion for argument 1 from 'main()::X' to 'void*' 
source.cpp:12:6: note: void f(void (*)()) 
source.cpp:12:6: note: no known conversion for argument 1 from 'main()::X' to 'void (*)()' 
source.cpp:21:6: note: template<class T> void f(T&&, EnableIf<sfinae_false<T> >) 
source.cpp:21:6: note: template argument deduction/substitution failed: