Question

我正在尝试使用SFINAE来检测作为模板参数T传递的类型是否具有T :: operator（）（P const＆amp;），其中P也是模板参数。我在Member Detector Idiom的这个例子之后对我的解决方案进行了建模。不幸的是，我无法让它适用于operator（），即使我可以让它为普通方法运行。

以下是一些示例代码，用于演示我面临的问题：

#include <iostream>
#include <iomanip>
#include <utility>
#include <type_traits>

using namespace std;

struct has
{
    void operator()(int const&);    
};

struct hasNot1
{
    void operator()(int);   
};

struct hasNot2
{
    void operator()();  
};

struct hasNot3
{
    void operator()(float); 
};

struct hasNot4
{
};

template<typename T, typename EDT>
struct is_callable_oper
{
      private:
                    typedef char(&yes)[1];
                    typedef char(&no)[2];

                    template <typename U, void (U::*)(EDT const &)> struct
                                                                        Check;
                    template<typename>
                    static yes test(...);

                    template <typename U>
                    static no
                            test(Check<U, &U::operator()>*);

                public:
                    static constexpr bool value = sizeof(test<T>(0))
                                                                == sizeof(yes);
};

int main() {
    cout << boolalpha << is_callable_oper<has, int&>::value << " " 
         << is_callable_oper<has, int>::value << " "
         << is_callable_oper<hasNot1, int&>::value << " "
         << is_callable_oper<hasNot2, int&>::value << " "
         << is_callable_oper<hasNot3, int&>::value << " "
         << is_callable_oper<hasNot4, int&>::value << endl;
    return 0;
}

在ideone（https://ideone.com/tE49xR）上运行它会产生： true false true true true true

我期待： true false false false false false

工作完成：

阅读此Stackoverflow question。我也关注了相关链接。
查找std :: declval，decltype。我还研究了非类型模板参数如何导致歧义。我一直在使用http://en.cppreference.com/。
阅读其他一些相关问题和链接。

注意：我正在使用带有C ++ 0x的gcc 4.6.3。

结束目标：检测此签名中包含的所有callables函数指针。

相关说明： 我仍然对某些概念感到困惑，如果你能回答这些问题，我将不胜感激。当然，如果他们属于一个单独的问题，请告诉我。

在这种情况下，我们可以使用declval而不是Check模板来触发SFINAE的歧义吗？
重载运算符的函数类型是什么？例如，在这种情况下，重载运算符是否具有以下类型：void (operator())(EDT const&)？
由于在此检查期间放弃了CV限定符，检查我传递的参数的常量的最佳方法是什么。\
我无法找到使用Boost来实现此目的的方法。我也坚持使用较旧的Boost版本1.43（会检查并更新确切的），我相信。如果没有理由推出自己的支票，那可能是最好的。

我仍然是这方面的初学者，如果这太基础，我真诚地道歉。如果您能指出我认为我应该关注的其他资源，我将不胜感激。与此同时，我将继续在线搜索并尝试解决方案。

编辑1

在与@Nir Friedman讨论问题之后，我开始意识到破坏隐式转换规则并实现完全匹配并不是我想要的。只要传递的类型可以转换，它应该没问题。我很感激指出如何实现这一目标。

编辑2

我将此问题标记为已关闭，因为@Sam Varshavchik回答了我提出的确切问题。如果有人对编辑1中提出的问题感兴趣，我会将其作为一个单独的问题提出，或者在此处发布我的解决方案以供参考。

Answer 1

在更现代的编译器上，这类问题的典型方法是void_t成语：How does `void_t` work。这是怎么回事。第1步：

template <class T>
using void_t = void;  // avoid variadics for simplicity

显然这是一般性的，并不是特定于你的问题，但直到17年它才会出现在标准库中。

接下来，我们定义我们的特征并将默认检测设为false：

template <class T, class P, class = void>
struct is_callable_oper : std::false_type {};

现在，我们定义了一个专门的表单，如果我们的函数有我们想要的运算符，它将会运行。

template <class T, class P>
struct is_callable_oper<T, P, 
    void_t<decltype(std::declval<T>()(std::declval<P>()))>>: std::true_type {};

基本的想法是，void_t我们知道将始终转换为void。但是，除非表达式有效，否则输入的类型将没有任何意义;否则会导致替换失败。所以基本上，上面的代码将检查是否

std::declval<T>()(declval<P>())

对你的类型是明智的。这基本上是你想要的特质检测。请注意，有一些涉及左值，右值，常量的细微差别，但这有点涉及到这里。

现在，正如Sam在评论中指出的那样，这个表达是否合理包括隐式转换。所以输出确实是真的真假真假。工作示例：http://coliru.stacked-crooked.com/a/81ba8b208b90a2ba。

例如，您希望is_callable_oper<has, int>::value为假。但是，显然可以使用const int&来调用接受int的函数。所以相反，你会变成现实。

Answer 2

您澄清了operator()返回void，并且您希望严格匹配签名，忽略类型转换。

如果是这样，那么您的预期结果应为false true false false false false，而不是true false false false false false：

 is_callable_oper<has, int&>::value

由于has::operator()不会使int & const &参数折叠为int &，因此此测试的结果必须为false。

 is_callable_oper<has, int>

由于has确实有一个带有operator()参数的const int &，因此该测试应该通过。

我的解决方案只是使用std::is_same来比较两种类型，std::enable_if与SFINAE相比 - 无法通过模板解析候选。

#include <type_traits>
#include <iostream>

struct has
{
    void operator()(int const&);
};

struct hasNot1
{
    void operator()(int);
};

struct hasNot2
{
    void operator()();
};

struct hasNot3
{
    void operator()(float);
};

struct hasNot4
{
};

template<typename T, typename P, typename foo=void>
class is_callable_oper : public std::false_type {};

template<typename T, typename P>
class is_callable_oper<T, P, typename std::enable_if<
         std::is_same<decltype(&T::operator()),
                      void (T::*)(const P &)>::value>::type>
    : public std::true_type {};

int main() {
    std::cout << std::boolalpha << is_callable_oper<has, int&>::value << " "
         << is_callable_oper<has, int>::value << " "
         << is_callable_oper<hasNot1, int&>::value << " "
         << is_callable_oper<hasNot2, int&>::value << " "
         << is_callable_oper<hasNot3, int&>::value << " "
          << is_callable_oper<hasNot4, int&>::value << std::endl;
    return 0;
}

编辑：通过使用std::void_t或合理的传真，在专业化中，也应该可以使用重载运算符：

template<typename T, typename P>
class is_callable_oper<T, P,
        std::void_t<decltype( std::declval< void (T::*&)(const P &)>()=&T::operator())>>
    : public std::true_type {};

为什么这个C ++特性可以检测类型T是否有一个void运算符（EDT const＆amp;）失败？

2 个答案: