C++ 从可变模板读取参数

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

考虑这一功能：

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

---

现在，我不知道如何扩展

func

的主体，以便能够分别读取每个参数，例如，我可以将参数存储在数组中。

您必须为函数提供覆盖，以便使用第一个

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
}

然后下一级，我们展开前面的

Rest

，得到：

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

以此类推，直到

Rest

不包含任何成员，在这种情况下，解包将调用

foo（）

（不带参数的重载）

---

如果包装类型不同，则储存包装 如果要存储整个参数包，可以使用

模板
无效存储包（包…p）{
std：：元组存储（p.）；
//对商店做些什么
}

然而，这似乎不太有用

如果包装是同质的，则储存包装 如果包中的所有值都是相同的类型，则可以按如下方式存储它们：

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

矢量反转（int i）{
向量ret；
后退（i）；
返回ret；
}
模板
向量反转（整数i，R…R）{
矢量ret=反向（r…）；
后退（i）；
返回ret；
}
int main（）{
自动v=倒档（1、2、3、4）；
对于每个（v.cbegin（），v.cend（），
[]（国际一）{
std:：cout如果需要在数组中存储参数，可以使用
boost:：any
数组，如下所示：

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

template int func（常量A&…参数）
{
任何arr[sizeof…（A）]={args…}；
返回0；
}
如果参数都是相同类型的，则可以将参数存储在如下数组中（使用数组的第一个参数的类型）：

如果参数具有不同的类型，则可以使用
std:：common_type

模板无效函数（A…args）{
typedef typename std:：common_type:：type common；
数组a={{args…}；
}

例如，
func（std:：string（“Hello”），“peoples”）
创建一个数组，其中包含
std:：string
您在上一个问题中遗漏了什么？（）为什么不接受您问题的答案？答案应该在链接的线程中（由Motti提供，无需向上投票？）@萨米：至少阅读一次常见问题解答……引用其中的话：
当你决定哪个答案对你最有帮助时，点击答案左侧的复选框提纲，将其标记为已接受的答案。
@sami：这不是重点。你问了5个问题，但没有接受任何答案。这一个有什么问题（）？如果你不想花10秒钟来感谢花时间帮助你的人，也许这不是一个适合你的好网站。@Motti：我明白你的意思。但我仍然有两个问题：1-如果我想指定数据类型，我可以这样调用函数foo:foo（42，true，'a'，'hello'））2-在哪里我可以读取值来存储在解包后我想存储的地方，这是我的主要问题！@sami，1.我不确定标准是怎么说的，但是g++接受
foo（42）
在这种情况下，我得到的是
*
而不是
42
，这意味着它将参数强制为
char
@sami，2。如果这些是不同的类型，则不能将它们存储在常规数组中（除非使用
boost:：any
或Kirill建议的类似方法）似乎结束条件应该放在第一位。@Motti:Thnaks.我不知道为什么有100多个示例描述如何解包和输出参数，同时没有示例描述如何单独存储每个参数。boost库是否也支持可变模板的STL容器？什么t是关于参数是否来自同一数据类型？不同类型值的标准“容器”是
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; 
        }
    );
}

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

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

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

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