Question

我想调用模板化函数并将两个参数集作为元组传递。但调用此函数需要始终使用std::make_tuple手动构建元组，然后再将其作为参数传递。

示例：

template < typename ... OUT, typename ... IN>
void Command( std::tuple<OUT...>, std::tuple<IN...>)
{
}


int main()
{
    // Send Parameter
    uint8_t mode;
    uint16_t addr;

    // Receive Parameter
    uint16_t neighbour0;
    uint16_t neighbour1;

    Command( std::make_tuple( mode, addr ),
             std::make_tuple( neighbour0, neighbour1 ));
}

是否有机会/技巧删除函数调用中的std::make_tuple，以便我可以编写如下内容：

Command( {mode, addr}, {neighbour0, neighbour1} );

Answer 1

如果符号

Command(mode, addr)(neighbour0, neighbour1);

是可以接受的，Command()本质上可以返回一个带有绑定的第一个std::tuple<...>的函数对象，它在接收其他参数时会调用实际的函数。那就是实施将是

template <typename... Out, typename... In>
void realCommand(std::tuple<Out...>, std::tuple<In...>);

template <typename... Out>
auto Command(Out&&... out) {
    return [&](auto&&... in){
        realCommand(std::make_tuple(std::forward<Out>(out)...),
                    std::make_tuple(std::forward<decltype(in)>(in)...));
    }
}

Answer 2

不，但你可以用这样的怪物保存一点点打字：

template<class...Ts>
auto _(Ts&&...ts)
{
    return std::make_tuple(std::forward<Ts>(ts)...);
}

...

Command(_(mode, addr),
        _(neighbour0, neighbour1));

通常的警告适用 - 仅仅因为我们可以，并不意味着我们应该......

在调用函数时生成隐式元组

2 个答案: