Enfoques para funcionar SFINAE en C ++

Estoy usando la función SFINAE en gran medida en un proyecto y no estoy seguro de si hay alguna diferencia entre los siguientes dos enfoques (aparte del estilo):

#include <cstdlib>
#include <type_traits>
#include <iostream>

template <class T, class = std::enable_if_t<std::is_same_v<T, int>>>
void foo()
{
    std::cout << "method 1" << std::endl;
}

template <class T, std::enable_if_t<std::is_same_v<T, double>>* = 0>
void foo()
{
    std::cout << "method 2" << std::endl;
}

int main()
{
    foo<int>();
    foo<double>();

    std::cout << "Done...";
    std::getchar();

    return EXIT_SUCCESS;
}

El resultado del programa es el esperado:

method 1
method 2
Done...

He visto que el método 2 se usa con más frecuencia en stackoverflow, pero prefiero el método 1.

¿Hay alguna circunstancia cuando estos dos enfoques difieren?

He visto que el método 2 se usa con más frecuencia en stackoverflow, pero prefiero el método 1.

Sugerencia: prefiera el método 2.

Ambos métodos funcionan con funciones individuales. El problema surge cuando tiene más de una función, con la misma firma, y ​​desea habilitar solo una función del conjunto.

Supongamos que desea habilitar foo(), versión 1, cuando bar<T>()(pretenda que es una constexprfunción) es true, y foo(), versión 2, cuándo bar<T>()es false.

Con

template <typename T, typename = std::enable_if_t<true == bar<T>()>>
void foo () // version 1
 { }

template <typename T, typename = std::enable_if_t<false == bar<T>()>>
void foo () // version 2
 { }

aparece un error de compilación porque tiene una ambigüedad: dos foo()funciones con la misma firma (un parámetro de plantilla predeterminado no cambia la firma).

Pero la siguiente solución

template <typename T, std::enable_if_t<true == bar<T>(), bool> = true>
void foo () // version 1
 { }

template <typename T, std::enable_if_t<false == bar<T>(), bool> = true>
void foo () // version 2
 { }

funciona, porque SFINAE modifica la firma de las funciones.

Observación no relacionada: también hay un tercer método: habilitar / deshabilitar el tipo de retorno (excepto para los constructores de clase / estructura, obviamente)

template <typename T>
std::enable_if_t<true == bar<T>()> foo () // version 1
 { }

template <typename T>
std::enable_if_t<false == bar<T>()> foo () // version 2
 { }

Como método 2, el método 3 es compatible con la selección de funciones alternativas con la misma firma.

Además de la respuesta de max66 , otra razón para preferir el método 2 es que con el método 1, puede (accidentalmente) pasar un parámetro de tipo explícito como el segundo argumento de plantilla y derrotar completamente el mecanismo SFINAE. Esto podría suceder como un error tipográfico, copiar / pegar, o como un descuido en un mecanismo de plantilla más grande.

#include <cstdlib>
#include <type_traits>
#include <iostream>

// NOTE: foo should only accept T=int
template <class T, class = std::enable_if_t<std::is_same_v<T, int>>>
void foo(){
    std::cout << "method 1" << std::endl;
}

int main(){

    // works fine
    foo<int>();

    // ERROR: subsitution failure, as expected
    // foo<double>();

    // Oops! also works, even though T != int :(
    foo<double, double>();

    return 0;
}

Demostración en vivo aquí