如何检测函数是否存在？

Question

我正在尝试检测我的函数的特定重载是否可调用。我以为我可以做类似于this answer 的事情，但我认为问题在于函数签名template<typename From, typename To> convert(const From&) 定义明确，但实例化不是。

#include <iostream>
#include <string>

template<typename From, typename To>
To convert(const From& from)
{
    // I have a lot of additional template specializations for this function
    return from; 
}

template<typename From, typename To>
struct IsConvertible
{
    template<typename = decltype(convert<From, To>(From()))>
    static std::true_type test(int);
    template<typename T>
    static std::false_type test(...);

    static bool const value = decltype(test(0))::value;
};

int main()
{
    std::cout << "IsConvertible=" << IsConvertible<int, float>::value << std::endl;
    // Returns 1 as expected

    std::cout << "IsConvertible=" << IsConvertible<int, std::string>::value << std::endl;
    // Returns 1, expected 0. The issue seems to be that decltype(convert<From, To>(From()))
    // is somehow ok, although convert<int, std::string>(1) definitly isn't
}

我想使用IsConvertible 进行一些额外的元编程。 是否可以检测到template<typename From, typename To> To convert(const From&) 函数是否真的可以调用？`

Answer 1

我可能误解了您的问题，但在这种情况下使用 std::is_invocable 还不够，如下所示？

#include<type_traits>

template<typename From, typename To>
To convert(const From& from)
{
    // I have a lot of additional template specializations for this function
    return from; 
}

template<>
std::string convert(const int& from)
{
    //silly specialization
    return "2"+from; 
}


struct Foo{
    int bar;
};

int main()
{
   //ok specialization is called 
   std::cout<<std::is_invocable<decltype(convert<int,std::string>),std::string>::value<<std::endl; 
   //no way I can convert int to Foo, specialization required
   std::cout<<std::is_invocable<decltype(convert<int,Foo>),Foo>::value<<std::endl; 
return 0;
}

Answer 2

声明

template<typename From, typename To> To convert(const From& from);

你的特点

template<typename From, typename To>
struct IsConvertible

总是会检测到convert 函数的存在。

修复它的一种方法是重载和/或 SFINAE：

template <typename> struct Tag{};

int convertImpl(tag<int>, const std::string& from);
float convertImpl(tag<float>, const std::string& from);
// overloads ...

template<typename From, typename To>
auto convert(const From& from)
-> decltype(convertImpl(tag<To>{}, from))
{
    return convertImpl(tag<To>{}, from);
}

Answer 3

我发现你的代码有一些问题。

没有特定的顺序...

(1) SFINAE，使用decltype()，只检查声明的函数是否存在；不检查该函数是否已定义或它的定义是否有效（编译）。

我建议你直接使用 SFINAE 重写convert() 以声明它只有在可编译时

template <typename To, typename From,
          decltype( To(std::declval<From>()), bool{} ) = true>
To convert (From const & f)
 { return f; }

只有当您可以从From 对象开始构造To 对象时，才会声明convert()。

(2) 请注意，我还切换了To 和From 的顺序：这样您就可以调用convert() 函数，只解释To 类型

convert<float>(0); // From is deduced as int from the 0 value

如果您在From（可推断）之后声明To（不可推断），则必须显式调用函数，同时在From 类型可推断时。

(3) 你的 IsConvertible 结构不起作用。

这是使用 SFINAE 的常见错误。

当你写作时

template<typename = decltype(convert<From, To>(From()))>
static std::true_type test(int);

您正在尝试使用 SFINAE 启用/禁用此 test() 方法，而不是 From 和 To，它们是 struct

的模板参数

错了。

SFINAE 对方法本身的模板参数起作用。

如果你想使用SFINAE，你必须在方法的模板参数中转换From和To；举例

template <typename F = From, typename T = To,
          typename = decltype(convert<F, T>(std::declval<F>()))>
static std::true_type test(int);

现在 SFINAE 使用 F 和 T 作为 test() 方法的模板参数，这是正确的。

(4) 注意我写的是std::declval<F>() 而不是F()。这是因为您不确定 F (From) 是默认可构造的。使用std::declval() 可以解决这个问题。

我提出了一个不同的IsConvertible 自定义类型特征，它考虑了From/To 倒置和对value 调用test() 的需求From+To->@987654358 @+T类型转换

template <typename To, typename From>
struct IsConvertible
 {
   template <typename T, typename F,
             typename = decltype(convert<T>(std::declval<F>()))>
   static std::true_type test(int);

   template <typename...>
   static std::false_type test(...);

   static bool const value = decltype(test<To, From>(0))::value;
 };

(5) 你期待

IsConvertible<int, std::string>::value

为零；但是您忘记了std::string 可以从int 构造；所以这个值（或IsConvertible<std::string, int>，切换To和From）应该是1。

以下是更正后的完整工作示例

#include <iostream>
#include <string>
#include <vector>

template <typename To, typename From,
          decltype( To(std::declval<From>()), bool{} ) = true>
To convert (From const & f)
 { return f; }

template <typename To, typename From>
struct IsConvertible
 {
   template <typename T, typename F,
             typename = decltype(convert<T>(std::declval<F>()))>
   static std::true_type test(int);

   template <typename...>
   static std::false_type test(...);

   static bool const value = decltype(test<To, From>(0))::value;
 };

int main ()
 {
   std::cout << "IsConvertible=" << IsConvertible<float, int>::value
      << std::endl;

   std::cout << "IsConvertible=" << IsConvertible<int, std::string>::value
      << std::endl;
 }