Crear plantilla dynamic. Lo que viene a ser tuple para struct, hacerlo para union.

[Pantaláimon]

He leído el enlace y no acabo de entender que es lo que debo aplicar. La persona está preguntando por cual de las 3 maneras es preferible usar std::enable_if.

La respuesta más puntuada habla de usar enable_if como un parámetro de un template. Entonces miro el código correspondiente:

Código C++:

template<typename T>
struct Check2
{
   template<typename U = T, typename std::enable_if<
            std::is_same<U, int>::value, int>::type = 0>
   U read() { return 42; }
 
   template<typename U = T, typename std::enable_if<
            std::is_same<U, double>::value, int>::type = 0>
   U read() { return 3.14; }   
};
 

Y observo algo que no acabo de entender como se comporta. ¿Se supone que si el primer "parámetro de enable_if es false, la plantilla donde está enable_if no se compilará? Hago la siguiente prueba basado en eso:

Código C++:

template<typename T>
struct A
{
   template<typename U, typename std::enable_if<
            std::is_same<U, int>::value, int>::type = 0>
   U foo(const U& u) { return 42; }
 
   template<typename U, typename std::enable_if<
            std::is_same<U, double>::value, int>::type = 0>
   U foo(const U& u) { return 3.14; }   
};
 
#include <type_traits>
#include <string>
 
int main() {
    A<int> x;
    std::cout << x.foo(1.8) << std::endl; // 3.14
    std::cout << x.foo(2) << std::endl; // 42
    return 0;
}
 

Hago una prueba más avanzada comparando el tipo T con el tipo U y si son iguales se implementará una función, si no son iguales se implementará otra:

Código C++:

template<typename T>
struct A
{
   template<typename U, typename std::enable_if<
            std::is_same<U, T>::value, int>::type = 0>
   int foo(const U& u) { return 42; }
 
   template<typename U, typename std::enable_if<
            !std::is_same<U, T>::value, int>::type = 0>
   double foo(const U& u) { return 3.14; }   
};
 
int main() {
    A<double> x;
    std::cout << x.foo(1.8) << std::endl; // 42
    std::cout << x.foo(2) << std::endl; // 3.14
    A<int> y;
    std::cout << y.foo(1.8) << std::endl; // 3.14
    std::cout << y.foo(2) << std::endl; // 42
    return 0;
}
 

Uau! funciona! Con esto ya puedo seguir avanzando.