C++ 将变量类型列表解压缩到变量

我有一个真正的问题。我试图通过从另一个agrument引导来提取一个函数的参数类型来构建参数。 所有这些都是为了删除代码的副本

一些信息：我使用gcc版本4.8.1

下面是我的最小化代码（有点长，很抱歉）：

序列化某个类型的类（仅以int为例）

好的，暂时没问题。现在我尝试将函数的调用更改为类似的形式（结果相同）

使用gdb，告诉我它在：Serializer:：~Serializer中崩溃

现在问题描述出来了，你能帮我吗

---

编辑：解决方案

#include <tuple>
#include <type_traits>
template<int...> struct index_tuple{};

template<int I, typename IndexTuple, typename... Types>
struct make_indexes_impl;

template<int I, int... Indexes, typename T, typename ... Types>
struct make_indexes_impl<I, index_tuple<Indexes...>, T, Types...>
{
    typedef typename make_indexes_impl<I + 1, index_tuple<Indexes..., I>, Types...>::type type;
};

template<int I, int... Indexes>
struct make_indexes_impl<I, index_tuple<Indexes...> >
{
    typedef index_tuple<Indexes...> type;
};

template<typename ... Types>
struct make_indexes : make_indexes_impl<0, index_tuple<>, Types...>
{};

// ----------UNPACK TUPLE AND APPLY TO FUNCTION ---------
//

template<class Ret, class... Args, int... Indexes>
Ret exec__( Ret (*pf)(Serializer&,Args...),Serializer& sock, index_tuple< Indexes... >, std::tuple<Args...>&& args)
{
    int ctx[] = { ((sock >> std::get<Indexes>(args)), void(), 0)... };
    (void)ctx;
    return pf(sock,std::forward<Args>(std::get<Indexes>(args))...);
};


template<typename Ret,typename ... Args>
Ret exec(Ret(*pf)(Serializer&,Args ...),Serializer& sock)
{
    return exec__(pf,sock,typename make_indexes<Args...>::type(), std::tuple<typename std::remove_reference<Args>::type...>());
}

#包括
#包括
模板结构索引_元组{}；
模板
结构生成索引；
模板
结构生成索引
{
typedef typename make_index_impl:：type type；
};
模板
结构生成索引
{
typedef索引\元组类型；
};
模板
结构生成索引：生成索引
{};
//------------解包元组并应用于函数---------
//
模板
Ret exec（Ret（*pf）（序列化器和，Args…），序列化器和sock，索引元组，std:：元组和Args）
{
intctx[]={（（sock>>std:：get（args）），void（），0）…}；
（无效）ctx；
返回pf（sock，std:：forward（std:：get（args））…）；
};
模板
Ret exec（Ret（*pf）（序列化程序和，参数…，序列化程序和sock）
{
返回exec（pf，sock，typename make_index:：type（），std:：tuple（））；
}

这应该可以做到：

template<typename T, T...>
struct integer_sequence
{ };

template<std::size_t... Indices>
struct indices : integer_sequence<std::size_t, Indices...>
{ };

template<std::size_t N, std::size_t... T>
struct build_indices : build_indices<(N - 1), (N - 1), T...>
{ };

template<std::size_t... T>
struct build_indices<0, T...> : indices<T...>
{ };

template<typename Fn, typename... Args, std::size_t... Idx>
auto exec__(Fn fn, Serializer& ser, std::tuple<Args...> args, indices<Idx...>)
-> decltype(fn(ser, std::get<Idx>(args)...))
{
    int ctx[] = { ((ser >> std::get<Idx>(args)), void(), 0)... };
    (void)ctx;
    return fn(ser, std::get<Idx>(args)...);
}

template<typename R, typename... Args>
auto exec(R(*fn)(Serializer&, Args...), Serializer& ser)
-> decltype(fn(ser, Args()...))
{
    return exec__(fn, ser, std::tuple<typename std::remove_reference<Args>::type...>(), build_indices<sizeof...(Args)>());
}

模板
结构整数序列
{ };
模板
结构索引：整数_序列
{ };
模板
结构构建索引：构建索引
{ };
模板
结构构建索引：索引
{ };
模板
自动执行（序列化器&ser，std:：tuple）
这应该可以实现以下功能：

template<typename T, T...>
struct integer_sequence
{ };

template<std::size_t... Indices>
struct indices : integer_sequence<std::size_t, Indices...>
{ };

template<std::size_t N, std::size_t... T>
struct build_indices : build_indices<(N - 1), (N - 1), T...>
{ };

template<std::size_t... T>
struct build_indices<0, T...> : indices<T...>
{ };

template<typename Fn, typename... Args, std::size_t... Idx>
auto exec__(Fn fn, Serializer& ser, std::tuple<Args...> args, indices<Idx...>)
-> decltype(fn(ser, std::get<Idx>(args)...))
{
    int ctx[] = { ((ser >> std::get<Idx>(args)), void(), 0)... };
    (void)ctx;
    return fn(ser, std::get<Idx>(args)...);
}

template<typename R, typename... Args>
auto exec(R(*fn)(Serializer&, Args...), Serializer& ser)
-> decltype(fn(ser, Args()...))
{
    return exec__(fn, ser, std::tuple<typename std::remove_reference<Args>::type...>(), build_indices<sizeof...(Args)>());
}

模板
结构整数序列
{ };
模板
结构索引：整数_序列
{ };
模板
结构构建索引：构建索引
{ };
模板
结构构建索引：索引
{ };
模板
自动执行（序列化器&ser，std:：tuple）
这应该可以实现以下功能：

template<typename T, T...>
struct integer_sequence
{ };

template<std::size_t... Indices>
struct indices : integer_sequence<std::size_t, Indices...>
{ };

template<std::size_t N, std::size_t... T>
struct build_indices : build_indices<(N - 1), (N - 1), T...>
{ };

template<std::size_t... T>
struct build_indices<0, T...> : indices<T...>
{ };

template<typename Fn, typename... Args, std::size_t... Idx>
auto exec__(Fn fn, Serializer& ser, std::tuple<Args...> args, indices<Idx...>)
-> decltype(fn(ser, std::get<Idx>(args)...))
{
    int ctx[] = { ((ser >> std::get<Idx>(args)), void(), 0)... };
    (void)ctx;
    return fn(ser, std::get<Idx>(args)...);
}

template<typename R, typename... Args>
auto exec(R(*fn)(Serializer&, Args...), Serializer& ser)
-> decltype(fn(ser, Args()...))
{
    return exec__(fn, ser, std::tuple<typename std::remove_reference<Args>::type...>(), build_indices<sizeof...(Args)>());
}

模板
结构整数序列
{ };
模板
结构索引：整数_序列
{ };
模板
结构构建索引：构建索引
{ };
模板
结构构建索引：索引
{ };
模板
自动执行（序列化器&ser，std:：tuple）
这应该可以实现以下功能：

template<typename T, T...>
struct integer_sequence
{ };

template<std::size_t... Indices>
struct indices : integer_sequence<std::size_t, Indices...>
{ };

template<std::size_t N, std::size_t... T>
struct build_indices : build_indices<(N - 1), (N - 1), T...>
{ };

template<std::size_t... T>
struct build_indices<0, T...> : indices<T...>
{ };

template<typename Fn, typename... Args, std::size_t... Idx>
auto exec__(Fn fn, Serializer& ser, std::tuple<Args...> args, indices<Idx...>)
-> decltype(fn(ser, std::get<Idx>(args)...))
{
    int ctx[] = { ((ser >> std::get<Idx>(args)), void(), 0)... };
    (void)ctx;
    return fn(ser, std::get<Idx>(args)...);
}

template<typename R, typename... Args>
auto exec(R(*fn)(Serializer&, Args...), Serializer& ser)
-> decltype(fn(ser, Args()...))
{
    return exec__(fn, ser, std::tuple<typename std::remove_reference<Args>::type...>(), build_indices<sizeof...(Args)>());
}

模板
结构整数序列
{ };
模板
结构索引：整数_序列
{ };
模板
结构构建索引：构建索引
{ };
模板
结构构建索引：索引
{ };
模板
自动执行（Fn-Fn，Serializer&ser，std：：tuple
我用c“onst Serializer*ctx[]={&（sock>>std：：get（tup））…}更改我的行得到了相同的结果，但也谢谢你的工作。但是…什么（ser>>std：：get（args）），void（），0）和（void）ctx；做什么呢？我用c“onst Serializer*ctx[]={&（sock>>std：：get（tup））更改我的行得到了相同的结果…}；“但是也谢谢你的工作。但是…什么（ser>>std:：get（args）），void（），0）和（void）ctx；做什么呢？我用c“onst Serializer*ctx[]={&（sock>>std:：get（tup））…}更改了我的行，得到了相同的结果。但是，也谢谢你的工作。但是…什么（ser>>std:：get（args）），void（），0）和（void）ctx；do？我用c“onst Serializer*ctx[]={&（sock>>std:：get（tup））…}”更改了我的行，得到了相同的结果，但是谢谢你的工作。但是…什么（ser>>std:：get（args）），void（），0）和（void）ctx；您的
delete\u缓冲区也不正确。应该是
delete[]\u buffer
。您的
delete\u buffer
也不正确。应该是
delete[]\u buffer
。您的
delete\u buffer
也不正确。应该是
delete[]\u buffer
。您的
delete\u buffer
也不正确。应该是
delete[]\u buffer
。
#include <tuple>
template<int...> struct index_tuple{};

template<int I, typename IndexTuple, typename... Types>
struct make_indexes_impl;

template<int I, int... Indexes, typename T, typename ... Types>
struct make_indexes_impl<I, index_tuple<Indexes...>, T, Types...>
{
    typedef typename make_indexes_impl<I + 1, index_tuple<Indexes..., I>, Types...>::type type;
};

template<int I, int... Indexes>
struct make_indexes_impl<I, index_tuple<Indexes...> >
{
    typedef index_tuple<Indexes...> type;
};

template<typename ... Types>
struct make_indexes : make_indexes_impl<0, index_tuple<>, Types...>{};

// ----------UNPACK TUPLE AND APPLY TO FUNCTION ---------

template<class Ret, class... Args, int... Indexes>
Ret apply_helper( Ret (*pf)(Serializer&,Args...),Serializer& sock, index_tuple< Indexes... >, std::tuple<Args...>&& tup)
{
    {sock>>std::get<Indexes>(tup)...};
    return pf(sock,std::forward<Args>(std::get<Indexes>(tup))...);
};

template<typename Ret,typename ... Args>
Ret apply(Ret (*pf)(Serializer&,Args...),Serializer& sock,const std::tuple<Args...>&  tup)
{
    return apply_helper(pf,sock,typename make_indexes<Args...>::type(), std::tuple<Args...>(tup));
};


template<typename Ret,typename ... Args>
Ret exec(Ret(*pf)(Serializer&,Args ...),Serializer& sock)
{
    std::tuple<Args ...> params;
    return apply(pf,sock,params);
}

{sock>>std::get<Indexes>(tup)...};

test.cpp: In function ‘Ret apply_helper(Ret (*)(Serializer&, Args ...), Serializer&, index_tuple<Indexes ...>, std::tuple<_Elements ...>&&)’:
test.cpp:129:34: error: expected ‘;’ before ‘...’ token
 {sock>>std::get<Indexes>(tup)...};
                                 ^
test.cpp:129:34: error: parameter packs not expanded with ‘...’:

const Serializer& c{sock>>std::get<Indexes>(tup)...};

getVersion : 42
param:42
testParamInt: 54
*** Error in `/media/HDD1/DEV/test': double free or corruption (top): 0x0000000000603010 ***
======= Backtrace: =========
...

*** Error in `./test': double free or corruption (top): 0x00000000007b8010 ***

#include <tuple>
#include <type_traits>
template<int...> struct index_tuple{};

template<int I, typename IndexTuple, typename... Types>
struct make_indexes_impl;

template<int I, int... Indexes, typename T, typename ... Types>
struct make_indexes_impl<I, index_tuple<Indexes...>, T, Types...>
{
    typedef typename make_indexes_impl<I + 1, index_tuple<Indexes..., I>, Types...>::type type;
};

template<int I, int... Indexes>
struct make_indexes_impl<I, index_tuple<Indexes...> >
{
    typedef index_tuple<Indexes...> type;
};

template<typename ... Types>
struct make_indexes : make_indexes_impl<0, index_tuple<>, Types...>
{};

// ----------UNPACK TUPLE AND APPLY TO FUNCTION ---------
//

template<class Ret, class... Args, int... Indexes>
Ret exec__( Ret (*pf)(Serializer&,Args...),Serializer& sock, index_tuple< Indexes... >, std::tuple<Args...>&& args)
{
    int ctx[] = { ((sock >> std::get<Indexes>(args)), void(), 0)... };
    (void)ctx;
    return pf(sock,std::forward<Args>(std::get<Indexes>(args))...);
};


template<typename Ret,typename ... Args>
Ret exec(Ret(*pf)(Serializer&,Args ...),Serializer& sock)
{
    return exec__(pf,sock,typename make_indexes<Args...>::type(), std::tuple<typename std::remove_reference<Args>::type...>());
}

template<typename T, T...>
struct integer_sequence
{ };

template<std::size_t... Indices>
struct indices : integer_sequence<std::size_t, Indices...>
{ };

template<std::size_t N, std::size_t... T>
struct build_indices : build_indices<(N - 1), (N - 1), T...>
{ };

template<std::size_t... T>
struct build_indices<0, T...> : indices<T...>
{ };

template<typename Fn, typename... Args, std::size_t... Idx>
auto exec__(Fn fn, Serializer& ser, std::tuple<Args...> args, indices<Idx...>)
-> decltype(fn(ser, std::get<Idx>(args)...))
{
    int ctx[] = { ((ser >> std::get<Idx>(args)), void(), 0)... };
    (void)ctx;
    return fn(ser, std::get<Idx>(args)...);
}

template<typename R, typename... Args>
auto exec(R(*fn)(Serializer&, Args...), Serializer& ser)
-> decltype(fn(ser, Args()...))
{
    return exec__(fn, ser, std::tuple<typename std::remove_reference<Args>::type...>(), build_indices<sizeof...(Args)>());
}