c++ - significa - persona que se expresa bien

¿Qué significa que cuando uno dice algo es compatible con SFINAE?

Question

No puedo comprender claramente lo que significa cuando se menciona que una función, estructura o ... es compatible con SFINAE .

¿Alguien por favor lo explicaría?

Answer 1

Una entidad se denomina compatible con SFINAE si se puede utilizar en el contexto de SFINAE sin producir un error grave en caso de fallo de sustitución. Supongo que ya sabes lo que es SFINAE, ya que esa es otra cuestión en sí misma.

En el contexto de la estandarización de C ++, el término SFINAE-friendly se ha aplicado hasta ahora a std::result_of y std::common_type . Tomemos el siguiente ejemplo:

template <typename T>
void foo(T x, typename std::common_type<T, int>::type y) {}

void foo(std::string x, std::string y) {}

int main()
{
    foo(std::string("hello"), std::string("world"));
}

Sin el common_type compatible con common_type , esto no se compilaría, porque std::common_type<std::string, int>::type produciría un error std::common_type<std::string, int>::type durante la sustitución del argumento de la plantilla. Con la introducción de common_type ( N3843 ) N3843 este ejemplo se vuelve bien formado, ya que std::common_type<std::string, int>::type produce un error de sustitución para que la sobrecarga se excluya del conjunto viable.

Aquí hay un ejemplo similar con result_of :

template <typename T>
auto bar(T f) -> typename std::result_of<T()>::type { return f(); }

void bar(int n) {}

int main()
{
    bar(42);
}

Sin el result_of compatible con result_of , esto no se compilaría, porque el tipo std::result_of<int()>::type produciría un error std::result_of<int()>::type durante la sustitución del argumento de la plantilla. Con la introducción de result_of ( N3462 ) N3462 este ejemplo se vuelve bien formado, porque el tipo std::result_of<int()>::type produce un fallo de sustitución por lo que la sobrecarga se excluye del conjunto viable.

Answer 2

Cuando permite el fallo de sustitución sin error duro (como static_assert ).

por ejemplo

template <typename T>
void call_f(const T& t)
{
    t.f();
}

La función se declara para todas las T , incluso las que no tienen f , por lo que no puede hacer SFINAE en call_f<WithoutF> ya que el método existe. ( Demo de código no compilador).

Con el siguiente cambio:

template <typename T>
auto call_f(const T& t) ->decltype(t.f(), void())
{
    t.f();
}

El método existe solo para una T. válida, por lo que puede usar SFINAE como

template<typename T>
auto call_f_if_available_impl(const T& t, int) -> decltype(call_f(t))
{
    call_f(t);
}

template<typename T>
auto call_f_if_available_impl(const T& t, ...)
{
    // Do nothing;
}

 template<typename T>
 auto call_f_if_available(const T& t)
 {
    call_f_if_available_impl(t, 0);
 }

Note que int = 0 y ... es para ordenar la sobrecarga. Demo

-

Otro caso es cuando la plantilla agrega un parámetro especial para aplicar SFINAE a la especialización:

template <typename T, typename Enabler = void> struct S;

Y entonces

// Specialization only available for T which respect the traits.
template <typename T>
struct S<T, std::enable_if_t<my_type_trait<T>::value>>
{
};