Sergio Pv:
Para ser honesto, no sé cómo empezar a buscar la solución para el problema que tratan de resolver. Probablemente una solución ya está. Así que la tarea está aquí.
Tengo una clase que en realidad es la plantilla con 2 argumentos:
template <typename F, typename S>
class trans {...};
También tengo otra clase que tiene una cadena de estas clases "trans" como una tupla (ejemplo):
class holder {
using chain_type = std::tuple<trans<std::string, int>,
trans<int, float>,
trans<float, std::string>,
trans<std::string, json>>;
};
Y como se puede ver cada segundo argumento de una "trans" es el mismo que el próximo primero. La cadena:
std::string -> int -> float -> std::string -> json.
¿qué me gustaría ... me gustaría tener algún método para hacer esta cadena como esta:
template <typename ...Args>
class holder {
using chain_type = trans_chain_create_t<Args...>;
};
holder<std::string, int, float, std::string, json> h;
¿Es posible? No estoy muy familiarizado con las plantillas variadic y las uso muy poco frecuente.
Andrey Semashev:
Sí, es posible:
template< typename F, typename S >
class trans {};
template< typename F, typename S, typename... Tail >
struct create_trans_chain;
template< typename F, typename S, typename... Tail >
using create_trans_chain_t = typename create_trans_chain< F, S, Tail... >::type;
template< typename F, typename S >
struct create_trans_chain< F, S >
{
using type = std::tuple< trans< F, S > >;
};
template< typename F, typename S, typename Next, typename... Tail >
struct create_trans_chain< F, S, Next, Tail... >
{
using type = decltype(std::tuple_cat(
std::declval< create_trans_chain_t< F, S > >(),
std::declval< create_trans_chain_t< S, Next, Tail... > >()));
};