modèle variadique récursif pour imprimer le contenu d'un paquet de paramètres
Comment est-il possible de créer un modèle variadique récursif pour imprimer le contenu d'un paquet paramater? J'essaie avec ça, mais ça ne compile pas:
template <typename First, typename ...Args>
std::string type_name () {
return std::string(typeid(First).name()) + " " + type_name<Args...>();
}
std::string type_name () {
return "";
}
comment mettre fin à la récursion?
4 réponses
vous devez utiliser une spécialisation partielle pour mettre fin à la récursion, mais comme vous ne pouvez pas partiellement spécialiser les fonctions libres en C++, vous devez créer une classe d'implémentation avec une fonction de membre statique.
template <typename... Args>
struct Impl;
template <typename First, typename... Args>
struct Impl<First, Args...>
{
static std::string name()
{
return std::string(typeid(First).name()) + " " + Impl<Args...>::name();
}
};
template <>
struct Impl<>
{
static std::string name()
{
return "";
}
};
template <typename... Args>
std::string type_name()
{
return Impl<Args...>::name();
}
int main()
{
std::cout << type_name<int, bool, char, double>() << std::endl; // "i b c d"
return 0;
}
cette première déclaration de Impl est juste une solution de contournement pour une lacune dans g++ 4.6 (et ci-dessous). Il ne sera pas nécessaire une fois qu'il implémente correctement les gabarits variadic.
il y a en fait une façon très élégante de mettre fin à la récursion:
template <typename Last>
std::string type_name () {
return std::string(typeid(Last).name());
}
template <typename First, typename Second, typename ...Rest>
std::string type_name () {
return std::string(typeid(First).name()) + " " + type_name<Second, Rest...>();
}
j'ai d'abord essayé template <typename Last> et template <typename First, typename ...Rest> mais cela a été considéré comme ambigu (Le reste peut être des éléments zéro). Cette question m'a alors montré la solution définitive: erreur de Compilation sur la fonction de modèle variadique récursive
Note, pour éviter un peu de duplication de code, vous pouvez aussi faire:
template <typename Last>
std::string type_name () {
return std::string(typeid(Last).name());
}
template <typename First, typename Second, typename ...Rest>
std::string type_name () {
return type_name<First>() + " " + type_name<Second, Rest...>();
}
comme alternative à la spécialisation partielle non-existante pour les fonctions, vous pouvez utiliser la surcharge sur une classe de typographie:
#include <string>
#include <iostream>
#include <typeinfo>
template <unsigned int N> struct NumberToType { };
template <typename T>
std::string my_type_name(NumberToType<0> = NumberToType<0>())
{
return std::string(typeid(T).name());
}
template <typename T, typename ...Args>
std::string my_type_name(NumberToType<sizeof...(Args)> = NumberToType<sizeof...(Args)>())
{
return std::string(typeid(T).name()) + " " + my_type_name<Args...>(NumberToType<sizeof...(Args)-1>());
}
int main()
{
std::cout << my_type_name<int, double, char>() << std::endl;
}
Comme alternative, vous pouvez décompresser le paramètre pack en place, comme dans l'exemple suivant:
#include<string>
#include<iostream>
#include<typeinfo>
template <typename T, typename ...Args>
std::string type_name () {
std::string str = typeid(T).name();
int arr[] = { 0, (str += std::string{" "} + typeid(Args).name(), 0)... };
(void)arr;
return str;
}
int main() {
auto str = type_name<int, double, char>();
std::cout << str << std::endl;
}
la Récursivité n'est pas nécessaire en fait de le faire.