Question

我有一个案例，我需要将输入参数应用于函数而不关心它是否是元组。如果它是一个元组，需要解压缩，因此不需要检测函数参数。

以下是我尝试过的内容：

template <typename Callable, typename Tuple>
auto geniune_apply(Callable&& callable, Tuple&& tuple)
{
    return std::apply(std::forward<Callable>(callable), std::forward<Tuple>(tuple));
}

template <typename Callable, typename T, typename = typename std::enable_if<!shino::is_tuple_like<std::decay_t<T>>::value>::type>
auto geniune_apply(Callable&& callable, T&& arg)
{
    return std::forward<Callable>(callable)(std::forward<T>(arg));
}

它导致歧义，这是我的预期。然后我尝试使用元组大小的SFINAE，但是我无法阻止非元组类型的编译错误。

以下是测试用例我正在使用：

#include <cassert>
#include <iostream>
#include <stdexcept>
#include <vector>

int dummy_x(const std::tuple<int, int>&)
{
    return 1;
}

int dummy_y(int y)
{
    return y;
}

int main()
{
    shino::geniune_apply(&dummy_x, std::tuple<int, int>(1, 1));
    shino::geniune_apply(dummy_y, 1);
    shino::geniune_apply(dummy_y, std::make_tuple(1));
}

如果需要，可以使用类似元组的代码。它基本上测试它是std::array还是std::tuple：

template <typename T>
    struct is_straight_tuple
    {
        static constexpr bool value = false;

        constexpr operator bool()
        {
            return value;
        }
    };

    template <typename ... Ts>
    struct is_straight_tuple<std::tuple<Ts...>>
    {
        static constexpr bool value = true;

        constexpr operator bool()
        {
            return value;
        }
    };

    template <typename T>
    struct is_std_array
    {
        static constexpr bool value = false;
    };

    template <typename T, std::size_t size>
    struct is_std_array<std::array<T, size>>
    {
        static constexpr bool value = true;

        constexpr operator bool()
        {
            return value;
        }
    };

    template <typename T>
    struct is_tuple_like
    {
        static constexpr bool value = is_std_array<T>::value || is_straight_tuple<T>::value;

        constexpr operator bool()
        {
            return value;
        }
    };

Answer 1

在C ++ 14中解决这个问题的最简单方法就是使用tag-dispatch：

template <typename Callable, typename Arg>
decltype(auto) geniune_apply(Callable&& callable, Arg&& arg)
{
    return details::genuine_apply(std::forward<Callable>(callable),
         std::forward<Arg>(arg),
         is_tuple_like<std::decay_t<Arg>>{});
}

将is_tuple_like更改为继承std::integral_constant<bool, ???>，而不是重新实现相同的内容。这将允许您编写这两个辅助函数：

namespace details {
    // the tuple-like case
    template <typename Callable, typename Tuple>
    decltype(auto) genuine_apply(Callable&&, Tuple&&, std::true_type );

    // the non-tuple-like case
    template <typename Callable, typename Arg>
    decltype(auto) genuine_apply(Callable&&, Arg&&, std::false_type );
}

在C ++ 17中，更好的解决方案是简单地使用if constexpr而不是标签分派。使用C ++ Concepts，您对问题的初始处理方法实际上将按原样工作（有一个不受约束的函数模板，一个约束在第二个参数上是元组的）。

如何扩展std :: apply以处理非元组类型？

1 个答案: