Рекурсивный шаблон переменной для распечатки содержимого пакета параметров

Question

Как можно создать рекурсивный вариационный шаблон для распечатки содержимого пакета paramater? Я пытаюсь с этим, но он не может скомпилировать:

template <typename First, typename ...Args>
std::string type_name () {
    return std::string(typeid(First).name()) + " " + type_name<Args...>();
}
std::string type_name () {
    return "";
}

Как мне закончить рекурсию?

Answer 1

Вам нужно использовать частичную специализацию для завершения рекурсии, но, поскольку вы не можете частично специализировать свободные функции в C++, вам нужно создать класс реализации со статической функцией-членом.

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;
}

Это первое заявление Impl это просто обходной путь для недостатка в g ++ 4.6 (и ниже). В этом нет необходимости, если он правильно реализует шаблоны с переменным числом аргументов.

Проверьте это в действии в ideone.com

Answer 2

На самом деле есть очень элегантный способ завершить рекурсию:

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...>();
}

Я изначально пробовал template <typename Last> а также template <typename First, typename ...Rest> но это считалось неоднозначным (покой может быть нулевым элементом). Затем этот вопрос показал мне окончательное решение: Ошибка компиляции в функции рекурсивного вариационного шаблона

---

Обратите внимание, чтобы избежать дублирования кода, вы также можете сделать:

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...>();
}

Answer 3

C++17-х if constexpr позволяет сделать это в одном объявлении шаблона, который, в отличие от многих старых решений, довольно легко понять:

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...>();
  }
}

Answer 4

В качестве альтернативы несуществующей частичной специализации для функций вы можете использовать перегрузку для класса-спецификатора:

#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;
}

Answer 5

В качестве альтернативы вы можете распаковать пакет параметров на месте, как показано в следующем примере:

#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;
}

На самом деле для этого не требуется рекурсия.

Answer 6

Используйте выражение сгиба С++17:

      template <typename ...Args>
std::string type_name () {
    return (std::string(typeid(Args).name()) + " " + ...);
}