继承和CRTP

Question

For practical reasons, I've got a class like

template <class A>
class CRTP
{
    template <int (A::*Member)()>
    int func(void * obj)
    {
        int result
        // Do something with Member, like
        // result = (reinterpret_cast<A*>(obj)->*Member)();
        return result;
    }
};

The template <void (A::*Member)()> is a requirement, it cannot be passed as an argument.

And I also have a class Base

class Base : public CRTP<Base>
{
    int aMemberOfBase() {...}
};

And its derived which I want to also inherit CRTP

class Derived : public CRTP<Derived>, public Base
{
    int aMemberOfDerived() {...}
};

In some member of Derived, I'll do something like

func<&Derived::aMemberOfDerived>(this);
func<&Base::aMemberOfBase>(this);

Is that possible ?

(Well, VC++ compile only the first line and don't want to read about the second one... but Derived should have the members

template <int (Base::*Member)()> int func(void * obj);
template <int (Derived::*Member)()> int func(void * obj);

which looks strange, I admit it. But the following piece of code

template <void (Base::*Member)()> int func() {return 0;}
template <void (Derived::*Member)()> int func() {return 1;}

compiles and return func<&Base::someMember>() != func<&Derived::someMember>() , because the signature of the template is not the same and can't be the same.)

I must admit that I'm not well award of what the standard says. But is the inheritance pattern I'm trying to make allowed? And if yes, why one of the line doesn't compile?

Moreover, if I declare

class Derived : public Base, public CRTP<Derived>

instead of

class Derived : public CRTP<Derived>, public Base

I get compile time error (on all the func<...>(...) ), which means that there's something wrong somewhere.

On the other hand, I know that

template <class A, int (A::*Member)()> int func(void * obj)

would remove the need of a CRTP, but it's painfull to write func<Derived, &Derived::aMember>() . Is there a workaround like

template <class Class, void (Class::*Member)()> class A 
{
    void func(void * obj) {...(reinterpret_cast<Class*>(obj)->*Member)();...} 
};
template <typename Signature> class B;

template <typename Class, typename Member>
class B<&Class::Member> : public class A<Class, &Class::Member> {};

which would allow B<&Base::Derived>().func(somePtrToBase) ?

Answer 1

You can disambiguate by qualifying the name of the base member template. The following should work:

template <typename A> struct CRTP
{
    template <int (A::*Member)()> int func();
};

struct Base : CRTP<Base>
{
    int aMemberOfBase();
};

struct Derived : CRTP<Derived>, Base
{
    int aMemberOfDerived();

    void foo()
    {
        CRTP<Derived>::func<&Derived::aMemberOfDerived>();
        CRTP<Base>::func<&Base::aMemberOfBase>();
    }
};

I made everything public to avoid getting bogged down in access control details.