C++元函数,用于确定类型是否可以为提供的参数调用

Question

我正在尝试实现一个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的编译器.

Answer 1

做你想做的事的简短用法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;

[现场演示]

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

编辑：

从有关解决方案可能存在的缺点的评论中详细阐述该主题。该std::result_of_t<T(Args...)>类型不需要配备默认的非参数构造函数，因此 sfinae 可能会导致callable_vfor 函数出现误报结果，从而导致此类类型。在评论中，我提出了一种解决该问题的方法，但它并没有真正解决问题或实际上生成一个新问题：

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;

[现场演示]