Why does this C++ trait to detect if a type T has a void operator(EDT const&) fail?

Question

I'm attempting to use SFINAE to detect if a type passed as a template argument T has an T::operator()(P const&) where P is also a template argument. I modeled my solution after this example of the Member Detector Idiom Unfortunately, I could not get this working for an operator(), even though I could get it to function for a normal method.

Here's some sample code that demonstrates the problem I'm facing:

#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;
}

Running it on ideone (https://ideone.com/tE49xR) produces: true false true true true true

I expected: true false false false false false

Work Done:

1. Read this Stackoverflow question. I've also followed related links.

2. Looked up std::declval, decltype. I've also studied a bit on how the non-type template parameter results in an ambiguity. I've been using http://en.cppreference.com/ primarily.

3. Read some other related questions and links.

Note: I'm working on gcc 4.6.3 with C++ 0x.

End Goal: Detect all callables function pointers included with this signature.

Related Clarifications: I'm still confused about some concepts, and I would be grateful if you could answer these. Of course, if they belong in a separate question, please do let me know.

1. Can we trigger the ambiguity for SFINAE by using declval rather than a Check template for this case?

2. What is the function type for an overloaded operator? For example, would the overloaded operator in this case have the following type: void (operator())(EDT const&)?

3. As CV Qualifiers are discarded during this check, what is the best way to check for the const-ness of the argument I'm passing.\

4. I haven't been able to figure out a way to use Boost to do this. I'm also stuck using an older Boost version 1.43 (Will check and update the exact), I believe. If there is no reason to roll my own check, that may be for the best.

I'm still very much a beginner in this area, and I sincerely apologize if this is too basic. I would appreciate it if you can point me to additional resources that you think I should be looking at as well. In the meantime, I'll keep searching online and trying solutions.

---

EDIT 1

---

After discussing the problem with @Nir Friedman, I have come to appreciate that breaking implicit conversion rules and achieving an exact match is not what I want. So long as the passed type can be converted, it should be fine. I would appreciate a pointer on how to achieve this.

---

EDIT 2

---

I'm marking this question as closed because @Sam Varshavchik answered the exact question I asked. If anyone is interested in the question posed in EDIT 1, I'll either ask it as a separate question, or post my solution here for reference.

Answer 1

On more modern compilers, the typical approach for this kind of problem is the void_t idiom: How does `void_t` work. Here's how it goes. Step 1:

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

Obviously this is general and not specific to your problem but it just doesn't happen to be in the standard library until 17.

Next, we define our trait and give the default detection as false:

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

Now, we defined a specialized form that will work out if our function has the operator we want.

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

The basic idea is that void_t as we know will always translate to void. But, the type being input will not make any sense unless the expression is valid; otherwise it will cause substitution failure. So basically, the code above will check whether

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

Is sensible for your type. Which is basically the trait detection that you want. Note that there are some subtleties involving lvalues, rvalues, constness, but that would be a bit involved to get into here.

Now, as Sam notes in the comments, whether this expression is sensible or not includes implicit conversions. So the output indeed is true true true false true false. Working example: http://coliru.stacked-crooked.com/a/81ba8b208b90a2ba.

For instance, you expected is_callable_oper<has, int>::value to be false. However, clearly one can call a function accepting const int& with an int. So instead you get true.

Answer 2

You clarified that your operator() returns a void, and you want to strictly match the signature, ignoring type conversions.

If that's so, then your expected results should be false true false false false false, and not true false false false false false:

 is_callable_oper<has, int&>::value

Since has::operator() does not take a int & const & parameter, which collapses to an int &, the result of this test must be false.

 is_callable_oper<has, int>

Since has does, indeed, have an operator() that takes a const int & parameter, this test should pass.

My solution simply uses std::is_same to compare two types, and std::enable_if to SFINAE-fail a template resolution candidate.

#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;
}

EDIT: By using std::void_t, or a reasonable facsimile, in the specialization it should also be possible to make this work with overloaded operators:

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 {};