在clang vs gcc和msvc中按方法指针的模板

Question

I have this function:

template <typename T, void (T::*pf)()>
void call(T& t)
{
    (t.*pf)();
}

If I have class foo with a method with the appropriate signature (say bar ) I can call it like this call<foo, &foo::bar>(); and it's fine. However if bar is const gcc and msvc are happy to compile it when called like this call<const foo, &foo::bar>() . Clang complains that the second template parameter is invalid. When I put const in the template arguments ( void (T::*pf)() const ) all tree compile it.

Now, this is not a huge issue, but my code becomes much much cleaner if I don't have to write this wretched const in the template arguments.

So the question basically is: What does the standard say about this? Is this a clang bug or are gcc and msvc just letting it slide because they're cool like that?

PS Here's a link to a complete repro program: http://codepad.org/wDBdGvSN

Answer 1

The const -ness of a method is part of the 'signature' of it. So, the proper way to define and use a pointer to member is:

R (Obj::*)(Args)       // for non-const member
R (Obj::*)(Args) const // for const member

Note that a const member can be called on a non-const object, which is not the case with R (const Obj::*)(Args) .

A way to solve this is to abstract such function pointers, by defining 'call wrappers':

template<typename O, void (O::* f)()>
struct NonConstFunc
{
    static void call(O* o)
    {
        (o->*f)();
    }
};

template<typename O, void (O::* f)() const>
struct ConstFunc
{
    static void call(O* o)
    {
        (o->*f)();
    }
};

Then, you can use it the following way (here the abstraction takes place):

template<typename Obj, typename Function>
void call(Obj* o)
{
    Function::call(o);
}

There is a live example here .

This is just the main idea. You can extend it with automatic detection of whether the method is const or not, without changing the user code.