On Fri, Apr 28, 2023 at 12:33 PM Jason McKesson wrote:
On Fri, Apr 28, 2023 at 10:55 AM Arthur O'Dwyer wrote:
> On Fri, Apr 28, 2023 at 7:36 AM Anoop Rana wrote:
>>
>> Since the type of a non-static member function is an ordinary function type and since we can't use decltype on a non-static member function to get its type, I propose that we should add a trait to get back the type of a non-static member function.
>
> I don't understand what you mean. The type of a non-static member function is not an "ordinary function type" in the usual sense of the phrase; it's a member function type.
> And `decltype` works just fine:
>
> // https://godbolt.org/z/Ea388neob
> struct S {
> int f() const;
> };
> static_assert(std::is_same_v<decltype(&S::f), int (S::*)() const>);
>
> Is it possible that you were actually trying to use `decltype(&S::g)` on an overload set?
> https://godbolt.org/z/fj94db8cT
>
> [...]
>>
>> using ret1 = decltype(GetType(&C::Func))::type; // void(std::string, int) as expected
>
> But that's not what's expected!  `C::Func` isn't a `void(std::string, int)` at all. It's a function of three parameters: the string, the int, and the hidden "this" parameter of type `C`. I cannot just pass a string and an int to it and have it work. It needs all three parameters in order to do its job.

You may have missed the `GetType` metafunction there.

No, I saw it, but... 

A deeper question is this: what exactly do you plan to *do* with this
information?

...that's exactly what I meant. The type of `C::Func` is not `void(std::string, int)`. You can't do anything with that information alone; you need the `C::` part in order to actually call the member function, or store a pointer to it somewhere, or pretty much anything else you might want to do with it.

Anyway, if you [Anoop] just want a type transformation to add or remove memberness, that's trivial to write. The only difficult part is coming up with a name.
https://godbolt.org/z/PWsq3xshY

template<class F, class T> using add_member_pointer_t = F T::*;

template<class T> struct remove_member_pointer { using type = T; };
template<class T, class P> struct remove_member_pointer<P T::*> { using type = P; };
template<class T> using remove_member_pointer_t = typename remove_member_pointer<T>::type;

// ------

struct C {
void f(int, int) const;
void g(int);
};

static_assert(std::is_same_v<add_member_pointer_t<void(int, int) const, C>, decltype(&C::f)>);
static_assert(std::is_same_v<add_member_pointer_t<void(int), C>, decltype(&C::g)>);
static_assert(std::is_same_v<void(int, int) const, remove_member_pointer_t<decltype(&C::f)>>);
static_assert(std::is_same_v<void(int), remove_member_pointer_t<decltype(&C::g)>>);

–Arthur