[temp.dep.general]

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.

An expression may be type-dependent (that is, its type may depend on a template parameter) or value-dependent (that is, its value when evaluated as a constant expression ([expr.const]) may depend on a template parameter) as described below.

A dependent call is an expression, possibly formed as a non-member candidate for an operator ([over.match.oper]), of the form:

postfix-expression ( expression-list

{o p t)}_{o p t)}

where the postfix-expression is an unqualified-id and

(2.1)
any of the expressions in the expression-list is a pack expansion ([temp.variadic]), or
(2.2)
any of the expressions or braced-init-lists in the expression-list is type-dependent, or
(2.3)
the unqualified-id is a template-id in which any of the template arguments depends on a template parameter.

The component name of an unqualified-id ([expr.prim.id.unqual]) is dependent if

(2.4)
it is a conversion-function-id whose conversion-type-id is dependent, or
(2.5)
it is operator= and the current class is a templated entity, or
(2.6)
the unqualified-id is the postfix-expression in a dependent call.

[Note 1:

Such names are looked up only at the point of the template instantiation ([temp.point]) in both the context of the template definition and the context of the point of instantiation ([temp.dep.candidate]).

— end note]

[Example 1: template<class T> struct X : B<T> { typename T::A* pa; void f(B<T>* pb) { static int i = B<T>::i; pb->j++; } };

The base class name B<T>, the type name T::A, the names B<T>::i and pb->j explicitly depend on the template-parameter.

— end example]