c – 是否应该在类成员访问表达式中为依赖类/名称空间名称延迟名

template<typename T>
void f(T t)
{
    t.Dependent::f(); // clang accepts,gcc rejects
    t.operator Dependent*(); // both reject
}

struct Dependent
{
     void f();
};

struct A : Dependent
{
     operator Dependent*();
};

template void f<A>(A);

我对该标准的解读表明这两种表达都应该被接受.

在这两种情况下,Dependent只能是类型名称.

在这两种情况下,名称Dependent将“在对象表达式的类中查找”t.由于t是依赖于类型的表达式,因此应该延迟查找,直到模板被实例化为止.

有什么我想念的吗？

编辑：如果打算这样的名称不依赖,这个决定的理由是什么？我可以看到,如果实现者不必延迟对t.operator X :: Dependent *或tX :: Dependent :: f这样的构造的评估,它会使实现者的生活更轻松,其中X可以是命名空间或类型名称.我不清楚这是否是当前措辞的预期或非预期的副作用.

C工作草案N3337的相关引用：

3.4.5 Class member access [basic.lookup.classref]

If the id-expression in a class member access is a qualified-id of the form
class-name-or-namespace-name::…
the class-name-or-namespace-name following the . or -> operator is first looked up in the class of the
object expression and the name,if found,is used. Otherwise it is looked up in the context of the entire
postfix-expression. [ Note: See 3.4.3,which describes the lookup of a name before ::,which will only find a
type or namespace name. —end note ]

If the id-expression is a conversion-function-id,its conversion-type-id is first looked up in the class of the
object expression and the name,is used. Otherwise it is looked up in the context of the entire
postfix-expression. In each of these lookups,only names that denote types or templates whose specializations
are types are considered.

14.6.2 Dependent names [temp.dep]

Inside a template,some constructs have semantics which may differ from one instantiation to another. Such a
construct depends on the template parameters. In particular,types and expressions may depend on the type
and/or value of template parameters (as determined by the template arguments) and this determines the
context for name lookup for certain names. Expressions may be type-dependent (on the type of a template
parameter) or value-dependent (on the value of a non-type template parameter).

[…]

Such names are unbound and are looked up at the point of the template instantiation (14.6.4.1) in both the
context of the template definition and the context of the point of instantiation.

14.6.2.1 Dependent types [temp.dep.type]

A name is a member of an unknown specialization if it is

[…]

— An id-expression denoting the member in a class member access expression (5.2.5) in which either

— the type of the object expression is the current instantiation,the current instantiation has at least
one dependent base class,and name lookup of the id-expression does not find a member of the
current instantiation or a non-dependent base class thereof; or

— the type of the object expression is dependent and is not the current instantiation.

[…]

A type is dependent if it is

— a member of an unknown specialization,