如何部分特化函数以调用以元组元素作为参数的函数

Question

我正在尝试使用未打包的元组调用函数，但我遇到了问题。我的代码依赖于在函数为零时对函数进行特殊处理的能力。此代码不起作用，但我如何使用有效的 C++ 完成此操作？

//Initialize Recursion
template <class ret, class ... Ts>
ret templateHelpers::callFunctionFromTuple(ret (*function)(Ts...), std::tuple<Ts...> tuple) {
    return callFunctionFromTupleHelper<sizeof...(Ts), ret>(function, tuple);
}

//Recursively break down the tuple
template <int NumLeft, class ret, class ... ArgsF, class ... ArgsT, class ... Args>
ret templateHelpers::callFunctionFromTupleHelper(ret (*function)(ArgsF...), std::tuple<ArgsT...> tuple, Args... ts) {
    return callFunctionFromTuple<numLeft - 1, ret>(funcTs(function, std::tuple<Tuples...> tuple, std::get<NumLeft-1>(tuple) Ts... ts));
}

//Finally Call the Function
//TODO: fix the error. Partial specialization does not work, including that <0>
template <class ret, class ... ArgsF, class ... ArgsT, class ... Args>
ret templateHelpers::callFunctionFromTupleHelper<0>(ret (*function)(ArgsF...), std::tuple<ArgsT...> tuple, Args... ts) {
    return func(ts...);
}

PS 我用的是 VS2017

Answer 1

C++ 中没有模板函数的偏特化。让您的函数遵循 class 可以部分专门化的模板。

namespace detail {
  template<...>
  struct callFunctionFromTupleImpl {
    static ret do_call(...) {
    }
  };

  // + more partial specializations
}

template <class ret, class ... Ts>
ret callFunctionFromTuple(ret (*function)(Ts...), std::tuple<Ts...> tuple) {
    return detail::callFunctionFromTupleHelperImpl<ret, Ts...>::do_call(function, tuple);
}

Answer 2

，因为我在不知道这里已经发布答案的情况下写了一个完美转发的完整解决方案

如果您不想考虑 possible implementation from cppreference for std::apply 并修改它以适合您的程序。您需要将调用委托给结构

#include <tuple>
#include <cassert>

namespace detail {
    template <int Size>
    struct InvokeHelper {
        template <typename Func, typename TupleType, typename... Args>
        static decltype(auto) apply(Func&& func, TupleType&& tup,
                                    Args&&... args) {
            constexpr auto tuple_size =
                std::tuple_size<std::decay_t<TupleType>>::value;
            return InvokeHelper<Size - 1>::apply(
                    std::forward<Func>(func),
                    tup,
                    std::forward<Args>(args)...,
                    std::get<tuple_size - Size>(
                        std::forward<TupleType>(tup)));
        }
    };
    template <>
    struct InvokeHelper<0> {
        template <typename Func, typename TupleType, typename... Args>
        static decltype(auto) apply(Func&& func, TupleType&&, Args&&... args) {
            return std::forward<Func>(func)(std::forward<Args>(args)...);
        }
    };
} // namespace detail

template <typename Func, typename TupleType>
decltype(auto) invoke_tuple(Func&& func, TupleType&& tup) {
    constexpr auto tuple_size = std::tuple_size<std::decay_t<TupleType>>::value;
    return detail::InvokeHelper<tuple_size>::apply(
            std::forward<Func>(func), std::forward<TupleType>(tup));
}

int main() {
    auto tup = std::make_tuple(1, 2);
    assert(invoke_tuple([](int a, int b) { return a + b; }, tup) == 3);
}

Answer 3

解压缩 std::tuple 的更简单方法是使用 sdt::index_sequence

#include<utility>
#include<tuple>

template<typename Ret, typename... Ts, size_t... I>
Ret callFunction_(Ret (*fn)(Ts...), std::tuple<Ts...> tup, std::index_sequence<I...>)
{
    return fn(std::get<I>(tup)...);
}

template<typename Ret, typename... Ts, typename Tuple>
Ret callFunction(Ret (*fn)(Ts...), Tuple&& tup)
{
    return callFunction_(fn, std::forward<Tuple>(tup),
        std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>{}>{});
}

Live

然后不需要委派给 class 模板 :)

Answer 4

您还可以使用 std::enable_if 实现您想要的功能。如果有任何打字错误，请提前道歉，因为接下来几天我不会靠近电脑。

template <std::size_t N, typename ret>
typename std::enable_if<N != 0, ret>::type f
(
)
{
    return f<N-1, ret>();
}

template <std::size_t N, typename ret>
typename std::enable_if<N == 0, ret>::type f
(
)
{
    return ret();
}

如何部分特化函数以调用以元组元素作为参数的函数

How to partially specialize function to invoke function with tuple elements as arguments

c++

templates

variadic-functions

variadic-templates