如何遍历打包的可变参数模板参数列表？

Question

我试图找到一种方法来迭代一个包可变参数模板参数列表。现在与所有迭代一样，您需要某种方法来了解打包列表中有多少参数，更重要的是如何从打包参数列表中单独获取数据。

总体思路是遍历列表，将所有 int 类型的数据存储到一个向量中，将所有 char* 类型的数据存储到一个向量中，并将所有浮点类型的数据存储到一个向量中。在此过程中，还需要一个单独的向量来存储参数输入顺序的各个字符。例如，当您 push_back(a_float) 时，您也在执行 push_back(‘f’)，它只是存储一个单独的字符来了解数据的顺序。我也可以在这里使用 std::string 并简单地使用 +=。该向量仅用作示例。

现在设计的方式是使用宏构造函数本身，尽管有恶意，但它是必需的，因为这是一个实验。所以实际上不可能使用递归调用，因为包含所有这些的实际实现将在编译时扩展；并且您不能重新生成宏。

尽管所有可能的尝试，我仍然坚持弄清楚如何实际做到这一点。因此，我使用了一种更复杂的方法，该方法涉及构造一个类型，并将该类型传递给 varadic 模板，将其扩展为一个向量，然后简单地对其进行迭代。但是我不想像这样调用函数：

 foo(arg(1), arg(2.0f), arg("three");

所以真正的问题是没有这样的我怎么办？为了让你们更好地理解代码实际在做什么，我粘贴了我目前正在使用的乐观方法。

 struct any {
  void do_i(int   e) { INT    = e; }
  void do_f(float e) { FLOAT  = e; }
  void do_s(char* e) { STRING = e; }

  int   INT;
  float FLOAT;
  char *STRING;
};

template<typename T> struct get        { T      operator()(const any& t) { return T();      } };
template<>           struct get<int>   { int    operator()(const any& t) { return t.INT;    } };
template<>           struct get<float> { float  operator()(const any& t) { return t.FLOAT;  } };
template<>           struct get<char*> { char*  operator()(const any& t) { return t.STRING; } };

#define def(name)                                  \
  template<typename... T>                          \
  auto name (T... argv) -> any {                   \
   std::initializer_list<any> argin = { argv... }; \
    std::vector<any> args = argin;
#define get(name,T)  get<T>()(args[name])
#define end }

any arg(int   a) { any arg; arg.INT    = a; return arg; }
any arg(float f) { any arg; arg.FLOAT  = f; return arg; }
any arg(char* s) { any arg; arg.STRING = s; return arg; }

我知道这很讨厌，但这是一个纯粹的实验，不会用于生产代码。这纯粹是一个想法。它可能可以做得更好。但是，您将如何使用此系统的示例：

 def(foo)
  int data = get(0, int);
  std::cout << data << std::endl;
end

看起来很像蟒蛇。它也可以，但唯一的问题是你如何调用这个函数。这是一个简单的例子：

 foo(arg(1000));

我需要构建一个新的 any 类型，它非常美观，但这并不是说这些宏也不是。顺便说一句，我只想选择这样做： foo(1000);

我知道这是可以做到的，我只需要某种迭代方法，或者更重要的是一些用于打包可变参数模板参数列表的 std::get 方法。我确信可以做到这一点。

另外需要注意的是，我很清楚这并不完全是类型友好的，因为我只支持 int,float,char* ，这对我来说没问题。我不需要其他任何东西，我将添加检查以使用 type_traits 来验证传递的参数确实是正确的参数，以便在数据不正确时产生编译时错误。这完全不是问题。除了这些 POD 类型之外，我也不需要任何支持。

如果我能得到一些建设性的帮助，我将不胜感激，反对关于我纯粹不合逻辑和愚蠢地使用宏和仅 POD 类型的争论。我很清楚代码是多么脆弱和破碎。这是 merley 的一个实验，我稍后可以纠正非 POD 数据的问题，并使其更加类型安全和可用。

感谢您的理解，我期待提供帮助。

原文由 graphitemaster 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

如果要将参数包装到 any ，可以使用以下设置。我还使 any 类更有用一些，尽管它在技术上不是 any 类。

 #include <vector>
#include <iostream>

struct any {
  enum type {Int, Float, String};
  any(int   e) { m_data.INT    = e; m_type = Int;}
  any(float e) { m_data.FLOAT  = e; m_type = Float;}
  any(char* e) { m_data.STRING = e; m_type = String;}
  type get_type() const { return m_type; }
  int get_int() const { return m_data.INT; }
  float get_float() const { return m_data.FLOAT; }
  char* get_string() const { return m_data.STRING; }
private:
  type m_type;
  union {
    int   INT;
    float FLOAT;
    char *STRING;
  } m_data;
};

template <class ...Args>
void foo_imp(const Args&... args)
{
    std::vector<any> vec = {args...};
    for (unsigned i = 0; i < vec.size(); ++i) {
        switch (vec[i].get_type()) {
            case any::Int: std::cout << vec[i].get_int() << '\n'; break;
            case any::Float: std::cout << vec[i].get_float() << '\n'; break;
            case any::String: std::cout << vec[i].get_string() << '\n'; break;
        }
    }
}

template <class ...Args>
void foo(Args... args)
{
    foo_imp(any(args)...);  //pass each arg to any constructor, and call foo_imp with resulting any objects
}

int main()
{
    char s[] = "Hello";
    foo(1, 3.4f, s);
}

然而，可以编写函数来访问可变参数模板函数中的第 n 个参数并将函数应用于每个参数，这可能是做任何你想要实现的更好的方法。

原文由 UncleBens 发布，翻译遵循 CC BY-SA 3.0 许可协议

Answer 2

#include <iostream>

template <typename Fun>
void iteratePack(const Fun&) {}

template <typename Fun, typename Arg, typename ... Args>
void iteratePack(const Fun &fun, Arg &&arg, Args&& ... args)
{
    fun(std::forward<Arg>(arg));
    iteratePack(fun, std::forward<Args>(args)...);
}

template <typename ... Args>
void test(const Args& ... args)
{
    iteratePack([&](auto &arg)
    {
        std::cout << arg << std::endl;
    },
    args...);
}

int main()
{
    test(20, "hello", 40);

    return 0;
}

输出：

 20
hello
40

原文由 chila 发布，翻译遵循 CC BY-SA 4.0 许可协议