web-dev-qa-db-fra.com

Modèle variable 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 pack de paramètres? J'essaye avec cela, mais cela 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 dois-je mettre fin à la récursion?

recursionc++11variadic-templatestypeid
40
Gabor Marton

Vous devez utiliser une spécialisation partielle pour mettre fin à la récursion, mais comme vous ne pouvez pas spécialiser partiellement les fonctions libres en C++, vous devez créer une classe de mise en œuvre 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 ne solution de contournement pour une lacune dans g ++ 4.6 (et ci-dessous). Il ne sera pas nécessaire une fois qu'elle implémente correctement les modèles variadiques.

Vérifiez-le en action sur Ideone.com

39
Peter Alexander

Il y a en fait un moyen très élégant 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 initialement essayé template <typename Last> et template <typename First, typename ...Rest> Mais cela était considéré comme ambigu (le repos peut être zéro des éléments). Cette question m'a alors montré la solution définitive: erreur de compilation sur la fonction de modèle variadique récursive

Remarque, pour éviter un peu de duplication de code, vous pouvez également 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...>();
}
42
Aberrant

Comme alternative à la spécialisation partielle non existante pour les fonctions, vous pouvez utiliser la surcharge sur une classe typique:

#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;
}
13
Kerrek SB

Comme alternative, vous pouvez décompresser le pack de paramètres 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écursion n'est pas nécessaire pour le faire.

6
skypjack

C++ 17's if constexpr vous permet de le faire dans une déclaration de modèle qui est, contrairement à beaucoup de solutions plus anciennes, assez facile à comprendre:

template <typename T, typename ...Args>
std::string type_name() {
  if constexpr (!sizeof...(Args)) {
    return std::string(typeid(T).name());
  } else {
    return std::string(typeid(T).name()) + " " + type_name<Args...>();
  }
}
3
user862857