我想要一个带有指向成员的指针的模板函数，但是我不想传递类类型或成员类型

Question

So I've been racking my brain trying to figure out a way to something. I thought I'd post it here to see if anyone has any ideas. Consider the following:

template <typename S, typename T, T S::* pMember>
bool SortByMember(const S& L, const S& R)
{
    return L.*pMember < R.*pMember;
}

...

struct SomeStruct
{
    int SomeMember;
};

void SomeFunction(void)
{
    GetSortByMember<&SomeStruct::SomeMember>();
}

I would like the function, GetSortByMember, to return a function pointer to the corresponding instantiation of SortByMember. However, I can't think of a way to declare/define GetSortByMember in a way that doesn't require the user to also pass the class type and the member type. This:

GetSortByMember<SomeStruct, int, &SomeStruct::SomeMember>();

is overly verbose and requires me to state the member type. I'm sure there's probably a solution in the boost libraries, but I'd rather not introduce that dependency to the project I'm working on.

I doubt highly that there's a solution that'll yield the exact syntax I used in the psudocode, but perhaps something can be done with template classes or macros?

The signature of SortByMember is expected by the class that will be using the function pointer, so it can't be changed.

Answer 1

Your example is not clear, presumably, you need to call the resulting function with two arguments? If so, why not use a getter function and pass that in, eg:

#include <iostream>

struct foo
{
  int bar;
  int getBar() const { return bar; }
};

template <typename S, typename U>
bool SortByMember(const S& L, const S& R, U f)
{
    return (L.*f)()< (R.*f)();
}

int main(void)
{
  foo a = {1};
  foo b = {2};

  std::cout << SortByMember(a, b, &foo::getBar) << std::endl;
}

Answer 2

There might be a nicer way to do what you want but this works using macros and the GCC specific typeof(). I'm not sure but there might be a portable way to do typeof in the new C++ standard.

#include <iostream>

template <class P, P p>
class sort_by_member_t;

template <class S, class T, T S::*p>
class sort_by_member_t<T S::*, p> {
public:
    typedef bool (*fn_t)(S const&, S const&);

    static bool fn(S const& L, S const& R)
    {
        return L.*p < R.*p;
    }
};

#define SORT_BY_MEMBER(p) sort_by_member_t<typeof(p), p>::fn;

struct SomeStruct
{
    int SomeMember;
};


int main()
{
    bool (*fp)(SomeStruct const&, SomeStruct const&);
    fp = SORT_BY_MEMBER(&SomeStruct::SomeMember);
    SomeStruct const a = { 1 };
    SomeStruct const b = { 2 };
    std::cerr
        << (void*) fp << ' '
        << (*fp)(a, b) << ' '
        << (*fp)(b, a) << ' '
        << '\n';

    return 0;
}