从可变参数模板中读取参数

Question

我有点困惑如何使用可变参数模板从元组中读取每个参数。

考虑这个函数：

template<class...A> int func(A...args){
int size = sizeof...(A);
.... }

我从主文件中调用它，例如：

func(1,10,100,1000);

现在，我不知道如何扩展 func 的主体，以便能够分别读取每个参数，例如，我可以将参数存储在数组中。

Answer 1

如果参数有不同的类型，你也可以使用std::common_type<>

template<class ...A> void func(A ...args){
   typedef typename std::common_type<A...>::type common;
   std::array<common, sizeof...(A)> a = {{ args... }};
}

例如，func(std::string("Hello"), "folks") 创建了一个 std::string 数组。

Answer 2

如果参数都是相同的类型，您可以将参数存储在这样的数组中（使用数组的第一个参数的类型）：

template <class T, class ...Args>
void foo(const T& first, const Args&... args)
{
    T arr[sizeof...(args) + 1] = { first, args...};
}

int main()
{
    foo(1);
    foo(1, 10, 100, 1000);
}

如果类型不同，我想你可以使用boost::any，但我看不出你将如何在给定模板之外找出哪个项目属于哪种类型（你将如何使用存储的值）。

---

编辑： 如果参数都是相同的类型，并且您想将它们存储到 STL 容器中，您可以使用std::initializer_list<T>。比如 Motti 逆向存储值的例子：

#include <vector>
#include <iostream>
#include <iterator>

template <class Iter>
std::reverse_iterator<Iter> make_reverse_iterator(Iter it)
{
    return std::reverse_iterator<Iter>(it);
}

template <class T>
std::vector<T> reverse(std::initializer_list<T> const & init)
{

    return std::vector<T>(make_reverse_iterator(init.end()), make_reverse_iterator(init.begin()));
}

int main() {
    auto v = reverse({1, 2, 3, 4});
    for (auto it = v.begin(); it != v.end(); ++it) {
        std::cout << *it << std::endl;
    }
} 

Answer 3

您必须为使用第一个 N（通常是一个）参数的函数提供覆盖。

void foo() {
   // end condition argument pack is empty
}

template <class First, class... Rest> 
void foo(First first, Rest... rest) {
    // Do something with first
    cout << first << endl; 

    foo(rest...); // Unpack the arguments for further treatment
}

当你解压可变参数时，它会找到下一个重载。

示例：

foo(42, true, 'a', "hello");
// Calls foo with First = int, and Rest = { bool, char, char* }
// foo(42, Rest = {true, 'a', "hello"}); // not the real syntax

然后下一层我们扩展之前的Rest 并得到：

foo(true, Rest = { 'a', "hello"}); // First = bool

以此类推，直到Rest 不包含任何成员，在这种情况下解包它调用foo()（不带参数的重载）。

---

不同类型的存储包

如果你想存储整个参数包，你可以使用std::tuple

template <class... Pack>
void store_pack(Pack... p) {
    std::tuple<Pack...> store( p... );
    // do something with store
}

然而这似乎没那么有用。

如果包装是同质的，则存放

如果包中的所有值都是同一类型，您可以像这样存储它们：

vector<int> reverse(int i) {
    vector<int> ret;
    ret.push_back(i);
    return ret;
}

template <class... R>
vector<int> reverse(int i, R... r) {
    vector<int> ret = reverse(r...);
    ret.push_back(i);
    return ret; 
}

int main() {
    auto v = reverse(1, 2, 3, 4);
    for_each(v.cbegin(), v.cend(), 
        [](int i ) { 
            std::cout << i << std::endl; 
        }
    );
}

然而这似乎甚至没有有用。

Answer 4

如果您需要在数组中存储参数，您可以使用boost::any 的数组，如下所示：

template<typename... A> int func(const A&... args)
{
  boost::any arr[sizeof...(A)] = { args... };
  return 0;
}