Taking a pointer to a protected method of the base class and passing it to a different class

Question

template <typename... Arguments>
class CCallback
{
public:
    template <class TargetClass>
    CCallback(TargetClass * target, void (TargetClass::*targetMethod)(Arguments...))
    {
    }
};

struct TargetClassBase
{
protected:
    void f() {}
};

struct TargetClassChild : TargetClassBase
{
    void g() {}

    void test()
    {
        CCallback<> callback(this, &TargetClassChild::f);
    }
} child;


void main()
{
}

That code doesn't compile in MSVC 2013:

error C2660: 'CCallback<>::CCallback' : function does not take 2 arguments

I don't understand why I get this specific error, and how to make it work. There are no further details about the error logged by the compiler.

And, of course, I can't properly specify that the method belongs to the base class (&TargetClassBase::f)- taking a pointer to a non-public base method is forbidden.

There is no function `TargetClassChild::f`. It simply does not exist. — Lightness Races in Orbit, Jan 06 '15 at 13:21
@LightnessRacesinOrbit: That is how it seems to me, too. But that seems to be a common workaround for "pointer to a protected base member function" problem: http://stackoverflow.com/questions/5822421/access-to-method-pointer-to-protected-method — Violet Giraffe, Jan 06 '15 at 13:23
@VioletGiraffe: Nowhere in that question or its answers (except tpdi's zero-scored answer, which doesn't make much sense to me tbh) does it say `&D::Foo`! — Lightness Races in Orbit, Jan 06 '15 at 13:25
@LightnessRacesinOrbit: I am merely refactoring the callback class, and before my refactoring it was capable of accepting exactly these 2 arguments. I'm trying to figure out how I've broken it, but don't see a difference so far. — Violet Giraffe, Jan 06 '15 at 13:26
@LightnessRacesinOrbit: the top-voted answer. It's the right one; I used that trick before. — Violet Giraffe, Jan 06 '15 at 13:27
@Deduplicator: hands off my `void`s, the more the better! I dislike `int`. — Violet Giraffe, Jan 06 '15 at 13:30
@VioletGiraffe: Well, it's not a question of preference but correctness. But if you also prefer to be wrong ;-) — Deduplicator, Jan 06 '15 at 13:34
@LightnessRacesinOrbit: `TargetClassChild::f` does exist. But it is function in class `TargetClassBase` not `TargetClassChild`. One can use functions from base classes qualifying them with derived class name like autor of question has done. — robal, Jan 06 '15 at 13:59

score 1 · Answer 1 · answered Jan 06 '15 at 13:51

Problem with your code is that compiler cannot deduce template type TargetClass in constructor for CCallback. This is because you pass arguments of types: TargetClassChild* and void (TargetClassBase::*)() to constructor. This is not a typo. Even if you write &TargetClassChild::f this expression still has type: pointer to function returning void in class TargetClassBase and not TargetClassChild as one could expect.

This kind of issues can be solved in two ways:

You could specify template type explicitly, but in this particular case it cannot be done because in C++ there is no way to explicitly pass template parameters to constructors as constructors don't have names (according to note in §14.5.2.5 of c++ standard).
Pass arguments of appropriate types to function. In this case simply cast your function to appropriate type like this static_cast<void (TargetClassChild::*)()>(&TargetClassChild::f)

Great, that works! And so does this: `CCallback<> callback((TargetClassBase*)this, &TargetClassChild::f);` — Violet Giraffe, Jan 06 '15 at 15:17
But still, why does MSVC throw this exact warning and not something more informative like type mismatch, ambiguous template parameter type deduction etc.? — Violet Giraffe, Jan 06 '15 at 15:29

Violet Giraffe · Accepted Answer · 2015-01-06T15:34:10.177

Expanding on robal's perfectly correct answer, I've rewritten the constructor of my class so that I don't need a manual type cast:

template <class TargetInstanceClass, class TargetMethodClass>
CCallback(TargetInstanceClass * target, void (TargetMethodClass::*targetMethod)(Arguments...))
{
   void (TargetInstanceClass::*targetInstanceMethod)(Arguments...) = static_cast<void (TargetInstanceClass::*targetInstanceMethod)(Arguments...)>(targetMethod);
}

Taking a pointer to a protected method of the base class and passing it to a different class

2 Answers2