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

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++ 中没有模板函数的部分特化。让您的函数遵循可以部分专门化的类模板。

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

解压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

然后不需要委托给类模板:)

Answer 3

In addition to what @StoryTeller said，因为我写了一个完美转发的完整解决方案，却不知道这里已经发布了答案

如果您不想考虑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 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();
}