Question

我得到了像这样的变量函数：

template<typename ... PARAMS>
static void processParameters( const PARAMS&... params);

我正在寻找一种简单有效的解决方案，用类似流的API（函数/运算符调用链）包装变量函数类似于：

(ParamList() << a << b << c).call();
or to this
call(ParamList() << a << b << c)

以便 call（）转换为 processParameters（a，b，c） 可能在构造/复制构造/破坏参数方面的开销很小。

我试图使一个有效的实现，但它基于元组，并且由于链调用中元组的构造/破坏而创建了太多的对象副本。

template<typename A1, typename... ARGS>
struct ParamList
{
        ParamList( const std::tuple<const A1&,const ARGS&...> &&tuple) : args(tuple) {}
        template<typename ARG>
        ParamList<A1,ARGS...,ARG> operator << (const ARG & arg)
        {
                return ParamList<A1,ARGS...,ARG>(std::tuple_cat(args,std::tuple<const ARG&>(arg)));
        }
        void call()
        {
                callProcessor(std::make_index_sequence<sizeof...(ARGS)+1>() );
        }
private:
        template<size_t... ISEQ>
        void callProcessor (std::index_sequence<ISEQ...> )
        {
                processParameters(std::get<ISEQ>(args)...);
        }
        const std::tuple<const A1&,const ARGS&...> args;
};

template<typename A1>
struct ParamList<A1>
{
        ParamList(const A1 & a1) : arg1(a1){}
        template<typename ARG>
        ParamList<A1,ARG> operator << (const ARG & arg)
        {
                return ParamList<A1,ARG>(std::tuple<constA1&,const ARG&>(arg1,arg)));
        }
        void call() { processParameters(arg1); }
private:
        const A1& arg1;
};
template<typename ARG> ParamList<ARG> makeParamList(const ARG &arg)
{
        return ParamList<ARG>(arg);
}

用法：

(makeParamList(A()) << B() << C() ).call();

如何将函数调用链转换为单个variardic templatre函数调用？

0 个答案: