我正在尝试实现一个 C++ 模板元函数，它确定一个类型是否可以从方法输入参数中调用。

即对于函数 void foo(double, double)元函数将返回 true对于 callable_t<foo, double, double> , true对于 callable_t<foo, int, int> (由于编译器进行隐式转换)和 false对于其他任何事情，例如参数数量错误 callable_t<foo, double> .

我的尝试如下，但是对于任何返回除 void 以外的任何内容的函数，它都失败了，我似乎无法修复它。

我是模板重新编程的新手，因此将不胜感激。

#include <iostream>
#include <type_traits>
#include <utility>
#include <functional>

namespace impl
{

template <typename...>
struct callable_args
{
};

template <class F, class Args, class = void>
struct callable : std::false_type
{
};

template <class F, class... Args>
struct callable<F, callable_args<Args...>, std::result_of_t<F(Args...)>> : std::true_type
{
};

}

template <class F, class... Args>
struct callable : impl::callable<F, impl::callable_args<Args...>>
{
};

template <class F, class... Args>
constexpr auto callable_v = callable<F, Args...>::value;


int main()
{
    {
        using Func = std::function<void()>;
        auto result = callable_v<Func>;
        std::cout << "test 1 (should be 1) = " << result << std::endl;
    }

    {
        using Func = std::function<void(int)>;
        auto result = callable_v<Func, int>;
        std::cout << "test 2 (should be 1) = " << result << std::endl;
    }

    {
        using Func = std::function<int(int)>;
        auto result = callable_v<Func, int>;
        std::cout << "test 3 (should be 1) = " << result << std::endl;
    }

    std::getchar();

    return EXIT_SUCCESS;
}

我正在使用支持 C++ 14 的编译器。

最佳答案

std::result_of的缩短使用做你想做的事情如下所示:

template <class T, class, class... Args>
struct callable: std::false_type {
};

template <class T, class... Args>
struct callable<T, decltype(std::result_of_t<T(Args...)>(), void()), Args...>:std::true_type {
};

template <class F, class... Args>
constexpr auto callable_v = callable<F, void, Args...>::value;

[live demo]

你需要记住 result_of 返回的类型始终是您按类型传递给此特征的函数的结果类型。为了让您的 sfinae 工作，您需要一种方法来在所有可能的情况下将此类型更改为无效。您可以通过使用 decltype ( decltype(std::result_of_t<T(Args...)>(), void()) ) 技巧来完成它。

编辑:

根据有关解决方案可能存在的缺点的评论来详细说明主题。 std::result_of_t<T(Args...)>类型不需要配备默认的非参数构造函数，因此 sfinae 可能会导致 callable_v 的假阴性结果对于导致这种类型的功能。在评论中，我针对这个问题提出了一个解决方法，但它并没有真正解决问题或实际上产生了一个新问题:

decltype(std::declval<std::result_of_t<T(Args...)>*>(), void())

这段代码的目的是让 sfinae 像以前提出的解决方案一样工作，但在不可构造类型的情况下，创建一个易于构造(我认为)指向给定类型的指针对象......在这个推理中我没有'不考虑不能创建指针的类型，例如引用。这又可以通过使用一些额外的包装类来解决:

decltype(std::declval<std::tuple<std::result_of_t<T(Args...)>>*>(), void())

或者通过衰减结果类型:

decltype(std::declval<std::decay_t<std::result_of_t<T(Args...)>>*>(), void())

但我认为这可能不值得，也许使用 void_t 实际上是一个更直接的解决方案:

template <class...>
struct voider {
    using type = void;
};

template <class... Args>
using void_t = typename voider<Args...>::type;

template <class T, class, class... Args>
struct callable: std::false_type {
};

template <class T, class... Args>
struct callable<T, void_t<std::result_of_t<T(Args...)>>, Args...>:std::true_type {
};

template <class F, class... Args>
constexpr auto callable_v = callable<F, void, Args...>::value;

[live demo]

关于C++ 元函数，它确定一个类型是否可以为提供的参数调用，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/40867617/