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

[Pantaláimon]

Buenas,

Leyendo el hilo sobre Crear una mascara.... Vi la implementación de eferion de la clase Variant y se me ocurrió crear una clase con variadic templates que hiciera lo mismo que la clase std::tuple de C++, pero en este caso, usando como base para la implementación union en vez de struct. Puediendo así crear una unión de tipos distintos así:

Código C++:

dynamic<int, float, char> a;
dynamic<int, std::string> b;
 

El problema es que yo nunca he profundizado en el tema de variadic templates, y me cuesta hacer la implementación. A ver si con la implementación de este ejemplo acabo aclarando algunas cosas sobre este tema. Me he bloquedado con lo siguiente:

Código C++:

#include <iostream>
 
template <typename... Types>
union dynamic; // undefined
 
template <>
union dynamic<> { }; // empty tuple
 
template <typename Head, typename... Tail>
union dynamic<Head, Tail...> {
    typedef Head type;
 
    Head first_elem;
    dynamic<Tail...> rest;
};
 
// definición de dynamic_element para conseguir el tipo de retorno de la función `get`
template<size_t, typename> struct dynamic_element;
 
template<typename T, typename... Ts>
struct dynamic_element<0, dynamic<T, Ts...>> 
{
    typedef T type;
};
 
template <size_t N, typename T, typename... Ts>
struct dynamic_element<N, dynamic<T, Ts...>> 
{
    typedef typename dynamic_element<N-1,dynamic<Ts...>>::type type;
};
 
// definición de la función `get` que obtiene el n-simo miembro de la union
template <typename T, typename... Ts>
typename dynamic_element<0, dynamic<T, Ts...> >::type& get(dynamic<T, Ts...>& tpl) noexcept {
    return tpl.first_elem;
}
 
template <size_t N, typename T, typename... Ts>
typename dynamic_element< N, dynamic<T, Ts...> >::type& get(dynamic<T, Ts...>& tpl) noexcept {
    return get<N-1>(tpl.rest);
}
 
int main() {
    dynamic<int,char> test;
    auto& num = get<0>(test);
    //num = 5;
    return 0;
}
 

La implementación de dynamic y dynamic_element las he implementado casi calcadas de ejemplos que he encontrado por internet al ver que mis intentos de implementarlas eran infructuosos. La función get, la he implementado intentando seguir el mismo patrón, pero claro, con la diferencia de que estoy implementando una función. Pero algo he hecho mal.

A ver si algún experto me podría ayudar a entender que hago mal.

Un saludo y gracias!

[eferion]

Le echaré un vistazo pero no prometo nada... Aún no he tenido que usar variadic templates en ninguna situación :)

[Pantaláimon]

De momento he cambiado un poco de estrategia ya que el constructor copia de la unión me estaba dando dolores de cabeza. Ahora tengo esto:

Código C++:

#define stringify(s) istringify(s)
#define istringify(s) #s
 
template <class... Ts> union variant {};
 
template<>
union variant<> {
  variant() {};
  ~variant() {};
}; 
 
template <class T, class... Ts>
union variant<T, Ts...> {
  variant() {};
  ~variant() {};
 
  T head;
  variant<Ts... > tail;
};
 
 
template<typename... Ts>
struct dynamic {
    std::string type;
    variant<Ts...> vnt;
};
 
int main() {
    dynamic<int, std::string> test;
    return 0;
}
 

Ahora toca definir constructores para dynamic al estilo:

Código C++:

template<typename U, typename T, typename... Ts>
typename dynamic<T, Ts>::dynamic(const U& u) :  
  /* si U == T --> type(stringify(U)), vnt(u) <-- constuctor no definido aún */
  /* si U != T -->  algun tipo de recursividad que tengo que pensar */
{ }
 

Mañana sigo pensando.

Un saludo!

[Pantaláimon]

La idea es hacer algo así:

Código C++:

template <typename T, typename... Ts>
union variant<T, Ts...> {
  variant() {};  
 
  template<typename U>
  std::conditional<
    std::is_same<U, T>,
    // si U == T, es el tipo correcto en el campo head actual 
    typename variant(const U& u) : head(u)
    { },
    // si U != T, no es el tipo correcto así que hay que seguir buscando 
    typename variant(const U& u) : tail(u) 
    { }
  >
 
  ~variant() {};
 
  T head;
  variant<Ts... > tail;
};
 

pero esto no compila.

[eferion]

Si lo haces para practicar templates me parece una práctica con bastante profundidad... ahora, a efectos prácticos creo que es mejor tener una clase para encapsular ese "union" por varias razones:

• No hay mucha diferencia a efectos de consumo de memoria entre declarar 20 tipos en un union o declarar únicamente 3
• Si intentas usar tipos no básicos "strings, clases propias" vas a tener que especializar el template, complicando el mantenimiento del código
• Un template al estilo "tuple", si bien puede ser muy útil en determinadas ocasiones, impone mucha rigidez al código. No puedes hacer un get iterativo de un "tuple" porque el "index" del get tiene que estar especificado en tiempo de compilación.
• Tienes que estar siempre pendiente del tipo de dato almacenado en cada posición del "union" para evitar conversiones no deseadas.

Si revisas el código fuente de "tuple" verás un poco la estructura que tiene que montar para funcionar... no es moco de pavo. En el caso de mi compilador, la implementación hace uso de media docena de archivos, con uso de macros y todo...

Un problema fundamental de este tipo de diseños es que la programación de templates en C++ acaba degenerando con gran facilidad en un código oscuro en el que la única persona capacitada para editar el código es el propio creador... y eso si aún se sigue acordando del diseño.

[Pantaláimon]

Vaya, pero yo no quería rendirme tan fácilmente. No sé que me pasa que siempre que cuando trato de hacer cosas un poco más complejas con plantillas siempre encuentro problemas que hacen siempre retirarme.

Ahora por ejemplo, olvidando por un momento el tema de tupla-unión. Me encuentro con esta problemática:

Código C++:

#include <type_traits>
 
class A {
    public:
        // un constructor con cualquier parámetro
        template<typename U>
        void foo(const U& u) {};
        
        // testeando que std::enable_if funcione bien
        void bar(const std::enable_if<true, int>::type& u) {};
 
        // probando ahora std::enable_if con una template... error
        template<typename U>
        void foobar(const typename std::enable_if<true, U>::type&) {};
};
 
int main() {
    A x;
    x.foo(3); // OK
    x.bar(6); // OK
    x.foobar(9); // error
    return 0;
}
 

No entiendo por qué el error, echo en falta que C++ responda de manera más intuitiva.

Un saludo!

[eferion]

Esto puede que te aclare un poco:

http://stackoverflow.com/questions/1...ion-signatures

Y estoy totalmente de acuerdo con que C++ debería dar mensajes un poco más consistentes...

[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.

[Pantaláimon]

¡Genial!

Esto ya empieza a tener cara y ojos:

Código C++:

#include <type_traits>
 
template <typename... Ts> union variant {};
 
template<>
union variant<> {
    public:
        template<typename U>
        variant(const U&) {};
};
 
template<typename T, typename... Ts>
union variant<T, Ts...>
{
    public: 
        template<typename U, typename std::enable_if<std::is_same<U, T>::value, int>::type = 0>
        variant(const U& u) : head(u) { }
 
        template<typename U, typename std::enable_if<!std::is_same<U, T>::value, int>::type = 0>
        variant(const U& u) : tail(u) { }
 
        T head;
        variant<Ts...> tail;
};
 
template<typename U, typename T, typename... Ts,
    typename std::enable_if<std::is_same<U, T>::value, int>::type = 0>
U get(const variant<T, Ts...>& vnt) {
    return vnt.head;
}
 
template<typename U, typename T, typename... Ts,
    typename std::enable_if<!std::is_same<U, T>::value, int>::type = 0>
U get(const variant<T, Ts...>& vnt) {
    return get<U>(vnt.tail);
}
 
int main() {
    variant<double, int> x = 1.8;
    std::cout << get<double>(x) << std::endl; // 1.8
    std::cout << get<int>(x) << std::endl; // no se almacena igual un int que un double, sale un numero raro
 
    variant<double, int> y = "blabla"; // esto debería dar error pero no lo da.
    //std::cout << get<unsigned>(x) << std::endl; // esto da error por no existir unsigned
    return 0;
}
 

Ahora toca pensar como restringir el numero de constructores a los definidos en el template.

Muchas gracias, eferion.

[eferion]

Iniciado por Pantaláimon

¡Genial!

Enhorabuena!!!!

Iniciado por Pantaláimon

Muchas gracias, eferion.

Si no he hecho nada!!! Me habría gustado ayudarte más, pero los templates son algo para sentarse con calma y tiempo y es algo de lo que ahora mismo ando algo escaso :(