13 Templates [temp]

13.8 Name resolution [temp.res]

13.8.3 Dependent names [temp.dep]

13.8.3.3 Type-dependent expressions [temp.dep.expr]

Except as described below, an expression is type-dependent if any subexpression is type-dependent.

this is type-dependent if the current class ([expr.prim.this]) is dependent ([temp.dep.type]).

An id-expression is type-dependent if it is a template-id that is not a concept-id and is dependent; or if its terminal name is

(3.1)
associated by name lookup with one or more declarations declared with a dependent type,
(3.2)
associated by name lookup with a non-type template-parameter declared with a type that contains a placeholder type,
(3.3)
associated by name lookup with a variable declared with a type that contains a placeholder type ([dcl.spec.auto]) where the initializer is type-dependent,
(3.4)
associated by name lookup with one or more declarations of member functions of a class that is the current instantiation declared with a return type that contains a placeholder type,
(3.5)
associated by name lookup with a structured binding declaration ([dcl.struct.bind]) whose brace-or-equal-initializer is type-dependent,
(3.6)
associated by name lookup with an entity captured by copy ([expr.prim.lambda.capture]) in a lambda-expression that has an explicit object parameter whose type is dependent ([dcl.fct]),
(3.7)
the identifier __func__ ([dcl.fct.def.general]), where any enclosing function is a template, a member of a class template, or a generic lambda,
(3.8)
a conversion-function-id that specifies a dependent type, or
(3.9)
dependent

or if it names a dependent member of the current instantiation that is a static data member of type “array of unknown bound of T” for some T ([temp.static]).

Expressions of the following forms are type-dependent only if the type specified by the type-id, simple-type-specifier, typename-specifier, or new-type-id is dependent, even if any subexpression is type-dependent:

simple-type-specifier ( expression-list

_{o p t}

)
simple-type-specifier braced-init-list
typename-specifier ( expression-list

_{o p t}

)
typename-specifier braced-init-list
::

_{o p t}

new new-placement

_{o p t}

new-type-id new-initializer

_{o p t}

_{o p t}

new new-placement

_{o p t}

( type-id ) new-initializer

_{o p t}

dynamic_cast < type-id > ( expression )
static_cast < type-id > ( expression )
const_cast < type-id > ( expression )
reinterpret_cast < type-id > ( expression )
( type-id ) cast-expression

Expressions of the following forms are never type-dependent (because the type of the expression cannot be dependent):

literal
sizeof unary-expression
sizeof ( type-id )
sizeof ... ( identifier )
alignof ( type-id )
typeid ( expression )
typeid ( type-id )
::

_{o p t}

delete cast-expression
::

_{o p t}

delete [ ] cast-expression
throw assignment-expression

_{o p t}

noexcept ( expression )
requires-expression

[Note 1:

For the standard library macro offsetof, see [support.types].

— end note]

A class member access expression is type-dependent if the terminal name of its id-expression, if any, is dependent or the expression refers to a member of the current instantiation and the type of the referenced member is dependent.

[Note 2:

In an expression of the form x.y or xp->y the type of the expression is usually the type of the member y of the class of x (or the class pointed to by xp).

However, if x or xp refers to a dependent type that is not the current instantiation, the type of y is always dependent.

— end note]

A braced-init-list is type-dependent if any element is type-dependent or is a pack expansion.

A fold-expression is type-dependent.

A pack-index-expression is type-dependent if its id-expression is type-dependent.