Created on 1999-08-26.00:00:00 last changed 162 months ago
[Moved to DR at October 2002 meeting.]
Proposed resolution (04/01):
Change the indicated text in 22.214.171.124 [over.match.call] paragraph 3:
The fourth case arises from a postfix-expression of the form &F, where F names a set of overloaded functions. In the context of a function call,
the set of functions named by F shall contain only non-member functions and static member functions. [Footnote: If F names a non-static member function, &F is a pointer-to-member, which cannot be used with the function call syntax.] And in this context using &F behaves the same as usingthe name F by itself. Thus, (&F)(expression-listopt) is simply (F)(expression-listopt), which is discussed in 126.96.36.199.2 [over.call.func]. (The resolution of &F in other contexts is described in 12.3 [over.over].)
188.8.131.52 [over.match.call] paragraph 3 says that when a call of the form
(&C::f)()is written, the set of overloaded functions named by C::f must not contain any nonstatic member functions. A footnote gives the rationale: if a member of C::f is a nonstatic member function, &C::f is a pointer to member constant, and therefore the call is invalid.
This is clear, it's implementable, and it doesn't directly contradict anything else in the standard. However, I'm not sure it's consistent with some similar cases.
In 12.3 [over.over] paragraph 5, second example, it is made amply clear that when &C::f is used as the address of a function, e.g.,
int (*pf)(int) = &C::f;the overload set can contain both static and nonstatic member functions. The function with the matching signature is selected, and if it is nonstatic &C::f is a pointer to member function, and otherwise &C::f is a normal pointer to function.
Similarly, 184.108.40.206.2 [over.call.func] paragraph 3 makes it clear that
C::f();is a valid call even if the overload set contains both static and nonstatic member functions. Overload resolution is done, and if a nonstatic member function is selected, an implicit this-> is added, if that is possible.
Those paragraphs seem to suggest the general rule that you do overload resolution first and then you interpret the construct you have according to the function selected. The fact that there are static and nonstatic functions in the overload set is irrelevant; it's only necessary that the chosen function be static or nonstatic to match the context.
Given that, I think it would be more consistent if the (&C::f)() case would also do overload resolution first. If a nonstatic member is chosen, the program would be ill-formed.
|2008-10-05 00:00:00||admin||set||status: wp -> cd1|
|2003-04-25 00:00:00||admin||set||status: dr -> wp|
|2002-11-08 00:00:00||admin||set||messages: + msg779|
|2002-11-08 00:00:00||admin||set||status: ready -> dr|
|2002-05-10 00:00:00||admin||set||status: review -> ready|
|2001-05-20 00:00:00||admin||set||messages: + msg487|
|2001-05-20 00:00:00||admin||set||status: open -> review|