Any way to determine if class implements operator()

Question

I'm trying to find is there's a way to check if a class is a functional because i want to write a template which uses it?

Is there an easy way to do this? Or do I just wrap things in a try/catch? Or perhaps the compiler won't even let me do it?

Answer 1

This would fall under doing it and getting a compiling error. When the code is compiled the template function or template classes are are expanded for the types used as if there were duplicate copies of that template code, one for each type.

So you can basically do whatever and as long as all the types used for your templates support it you have no problem. If they don't support it you have a compiling error and you can't run your code without fixing it.

template <typename T>
void DoIt(T a)
{
    a.helloworld();//This will compile fine
    return a();//This will cause a compiling error if T is B
}

class A
{
public:
    void a.helloworld(){}
    void operator()(){}
};

class B
{
public:
    void a.helloworld(){}
};

int main(int argc, char**argv)
{
    A a;
    B b;
    DoIt(a);
    DoIt(b);//Compiling error

    return 0;
}

Answer 2

If you have a function template written like:

template <typename T>
void f(T x)
{  
    x();  
}  

you will be unable to instantiate it with any type that is not callable as a function taking no arguments (e.g., a class type that overloads operator() taking no arguments is callable as a function that takes no arguments). You would get a compilation error if you tried to do so.

This is the simplest way to require the type with which a template is instantiated to have certain properties: just rely on the type having those properties when you write the template, and if the type doesn't have one of the required properties, it will be impossible to instantiate the template with that type.

Answer 3

There are quite a few ways a parameter type can be applicable to the call syntax

1. Type is a pointer or reference to a function type, or
2. Type is a class-type which has a conversion function to one of the types in 1., or has an applicable operator().

The current C++ cannot check for 2., so you are left without checking, like the other answers explain.

Answer 4

If you actually need a test to see if type T implements an operator() of some given signature then you could use the same SFINAE trick used to identify the existence of any other class member that is discussed here: http://stackoverflow.com/questions/3034477/c-if-then-else-template-substitution/3034911#3034911