你如何获得成员函数的类型

Question

The question is inspired by a note in the standard [class.mem]

The type of a non-static member function is an ordinary function type, and the type of a non-static data member is an ordinary object type. There are no special member function types or data member types.

So, I decided to test it

struct S
{
    using Fn = void();
    Fn foo;

    static_assert(std::is_same_v<decltype(foo), Fn>);
};

But its an error at decltype(foo) : invalid use of non-static member fucntion .

How do you get the type of a member function? Or is the note just bogus?

Note: It is valid to do this to data members

struct U
{
    int i;
    static_assert(std::is_same_v<decltype(i), int>);
};

Note2: I'm not looking for how to grab the type through a pointer-to-member

template<typename>
struct NotLikeThis;
template<typename C, typename R, typename... Args>
struct NotLikeThis<R (C::*)(Args...)>
{
    using type = R(Args...);
};

The note from the standard is irrelevant to this.

Answer 1

The standard explicitly states that you can't do this.

[expr.prim.id]

2 An id-expression that denotes a non-static data member or non-static member function of a class can only be used :

(2.1) as part of a class member access in which the object expression refers to the member's class ⁵⁸ or a class derived from that class, or

(2.2) to form a pointer to member ( [expr.unary.op] ), or

(2.3) if that id-expression denotes a non-static data member and it appears in an unevaluated operand.

[ Example:

 struct S { int m; }; int i = sizeof(S::m); // OK int j = sizeof(S::m + 42); // OK

— end example ]

Note my emphasis on can only be used : Those are the only ways that you can use an expression denoting a member function. Any other way you can come up with is ill-formed.

Note that 2.3 is exactly what you want to to - to use S::m ( m being a member function) in an unevaluated context (ie: decltype ), but it specifically (and I would assume deliberately ) only applies to data members.

I can think of at least one implication of allowing this (See below). There's probably more.

• Let's assume m is declared as void m(); and it is a member of class S . If decltype(S::m) is valid, then std::add_pointer<decltype(S::m)> should also be valid.
  Considering that member functions have the implicit this parameter, what would this second type be? void (S::*)() , or maybe something like void (*)(S*) ? Or even void (*)() ? It may be obvious to us that we want void (S::*)() , but knowing that S::m is just a regular function type, why would add_pointer turn it into a pointer-to-member? How could it even differentiate it?