In section ref(NAMERESFUN) the distinction between code depending on template
parameters and code not depending on template parameters was introduced.
The same distinction also holds true when class templates are defined and
used.

    Code not depending on template parameters is verified by the compiler when
the template is defined. If a member function in a class template uses a
ti(qsort) function, then tt(qsort) does not depend on a template
parameter. Consequently, tt(qsort) must be known to the compiler when it
encounters tt(qsort)'s function call. In practice this implies that the
tthi(cstdlib) header file must have been read by the compiler before it
is able to compile the class template definition.

    On the other hand, if a template defines a tt(<typename Ret>) template
type parameter to parameterize the return type of some template member
function as in:
        verb(
    Ret member();
        )
    then the compiler may encounter tt(member) or the class to which
tt(member) belongs in the following locations:
    itemization(
    it() the location where a class template object is defined. This is called
the
        emi(point of instantiation) of the class template object.
    The compiler must have read the class template's implementation and has
performed a basic check for syntactic correctness of member functions like
tt(member). It won't accept a definition or declaration like tt(Ret &&
*member), because bf(C++) does not support functions returning pointers to
rvalue references. Furthermore, it checks whether the actual type name
that is used for instantiating the object is valid. This type name must be
known to the compiler at the object's point of instantiation.
    it() the location where the template member function is used. This is
called the template member function's point of instantiation. Here
the tt(Ret) parameter must have been specified (or deduced) and at this point
tt(member)'s
statements that depend on the tt(Ret) template parameter are checked for
syntactic correctness. For example, if tt(member) contains a statement
like
        verb(
    Ret tmp(Ret(), 15);
        )
    then this is in principle a syntactically valid statement. However, when
tt(Ret = int) the statement fails to compile as tt(int) does not have a
constructor expecting two tt(int) arguments. Note that this is em(not) a
problem when the compiler instantiates an object of tt(member)'s class.  At
the point of instantiation of the object its member function `tt(member)' is
not instantiated and so the invalid tt(int) construction remains undetected.
    )
