Question

I’ve tried to create a template helper for member function pointers, the main idea is to be able to do things like this:

template <typename T, typename R> struct TStruct
{
    typedef T value_type;
    typedef R return_type;

    R Function(T &);
};

struct Struct
{
    int Function(const int &);
};

typedef TStruct<const int &, int> A;

FunctionPointer<A, A::return_type, A::value_type>::pointer p = &A::Function;
typedef FunctionPointer<Struct, int, const int &>::pointer FPointer;

While doing it I realized that declaring pointer without the helper is shorter (this isn’t the question now 😉 but it drived me to an error that I don’t understand. Let’s supose that we have two versions of the helper:

template <typename Type, typename Return, typename Parameter> struct Good
{
    typedef Return (Type::*pointer)(Parameter);
};

template <typename Type, typename Return, typename Parameter, Return (Type::*Pointer)(Parameter)> struct Bad
{
    typedef Parameter pointer;
};

The Good one defines the pointer to member function type into the struct body, and the Bad one defines it into the template parameters and then typedef it into the struct body.

Using the Good struct my test program compiles:

int main(int argc, char **argv)
{
    // No compilation errors
    Good<A, A::return_type, A::value_type>::pointer GoodTStructPtr = &A::Function;
    Good<Struct, int, const int &>::pointer GoodStructPtr = &Struct::Function;

    return 0;
}

But if the Bad struct is used, there is a compilation error:

int main(int argc, char **argv)
{
    // invalid initialization of reference of type ‘const int&’
    // from expression of type ‘int (TStruct<const int&, int>::*)(const int&)’
    Bad<A, A::return_type, A::value_type, &A::Function>::pointer BadTStructPtr = &A::Function;

    // invalid initialization of reference of type ‘const int&’
    // from expression of type ‘int (Struct::*)(const int&)’
    Bad<Struct, int, const int &, &Struct::Function>::pointer BadStructPtr = &Struct::Function;

    return 0;
}

AFAIK, Good::pointer and Bad::pointer are both of the type Return (Type::*)(Parameter) so they must be able to point to &A::Function or Struct::Function, but I’m clearly wrong but I don’t know why. It seems that there’s a different behaviour while the type is declared into a templated object body and when it is declared as template parameter.

So the question is: Why isn’t working the Bad::pointer as function pointer to the &A::Function or &Struct::Function?

Answer 1

Did you mean?

template <typename Type, 
          typename Return, 
          typename Parameter, 
          Return (Type::*Pointer)(Parameter)> struct Bad
{
    typedef Pointer pointer;
    //      ^^^^^^^ (not Parameter)
};