Recursion 用于打印参数包内容的递归变量模板

如何创建递归变量模板来打印参数包的内容？ 我正在尝试此功能，但无法编译：

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

模板
std:：字符串类型\u名称（）{
返回std:：string（typeid（First）.name（））+“”+type_name（）；
}
std:：字符串类型\u名称（）{
返回“”；
}

---

如何结束递归？

< p>您需要使用部分专门化来结束递归，但是由于不能部分地专门化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；
模板
结构Impl
{
静态std:：字符串名称（）
{
返回std:：string（typeid（First）.name（））+“”+Impl（及以下）。一旦它正确地实现了可变模板，就不需要它了

作为不存在的函数部分专门化的替代方法，您可以在Typefier类上使用重载：

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

#包括
#包括
#包括
模板结构NumberToType{}；
模板
std:：string我的类型名称（NumberToType=NumberToType（））
{
返回std:：string（typeid（T）.name（））；
}
模板
std:：string我的类型名称（NumberToType=NumberToType（））
{
返回std:：string（typeid（T）.name（））+“”+my_type_name（NumberToType（））；
}
int main（）
{
std:：cout实际上有一种非常优雅的方法可以结束递归：

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

模板
std:：字符串类型\u名称（）{
返回std:：string（typeid（Last）.name（））；
}
模板
std:：字符串类型\u名称（）{
返回std:：string（typeid（First）.name（））+“”+type_name（）；
}

我最初尝试了
template
和
template
，但这被认为是不明确的（其余可以是零元素）。然后，这个问题向我展示了最终的解决方案：


注意，为了避免代码重复，您还可以执行以下操作：

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

模板
std:：字符串类型\u名称（）{
返回std:：string（typeid（Last）.name（））；
}
模板
std:：字符串类型\u名称（）{
返回类型_name（）+“”+type_name（）；
}
作为替代方案，您可以按以下示例将参数包解包到位：

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

#包括
#包括
#包括
模板
std:：字符串类型\u名称（）{
std:：string str=typeid（T）.name（）；
int arr[]={0，（str+=std:：string{”“}+typeid（Args.name（），0）…}；
（无效）arr；
返回str；
}
int main（）{
auto str=类型_name（）；
std:：coutC++17的
if constexpr
允许您在一个模板声明中执行此操作，这与许多旧的解决方案不同，非常容易理解：

模板
std:：字符串类型_name（）{
如果constexpr（！sizeof…（Args））{
返回std:：string（typeid（T）.name（））；
}否则{
返回std:：string（typeid（T）.name（））+“”+type_name（）；
}
}
您引用的变通方法链接已失效。您能详细说明在没有错误的g++的情况下执行此操作的正确方法吗？虽然此答案是正确的，但已过时。可以使用更简单的方法，请参阅其他答案。当模板参数为模板时，此技术也有效（可变模板由模板参数组成）请注意，如果参数包为空，这将不起作用，但在其他情况下，这是一个非常好的解决方案。只需为空案例添加第三个重载（如果需要）我个人会使用这个解决方案，但是，为了完整起见，C++11允许您使用
std:：enable_if
指定只有当有两个以上的参数时才需要匹配可变大小写：
typename std:：enable_if=1，int>：：type=0
编译错误，原因是
constepr
函数声明（VS2015更新3）.如果可以的话，所有的都会编译removed@skypkack，我使用
/std:c++最新版本
编译，即支持
c++17
。错误为：
Error C3250'str'：不允许在'constexpr'函数体中声明
和
Error C3250'arr'：不允许在'constexpr'函数体中声明
@Macias无特别之处，这是折叠表达式的C++17之前版本的替代方案。它展开参数包并执行操作。@skypjack其优点：）您可以像这样编写函数体：
return（std:：string（typeid（Args）.name（）+std:：string（“”）+…）；
然后您应该删除第一个模板参数T。@Macias是的，但Q/A是从2016年开始的。-）我认为这个答案应该更高一点