Re: name binding from one template to another
"George" <George@discussions.microsoft.com> wrote in message
news:C5F3FA53-B692-46CE-9C23-E1BA01F6D5BD@microsoft.com
My confusion is, a compiler should do two major working items,
1. Identify the type of variable;
2. Identify referred symbols (find declaration), like function call.
If either task can not be completed when paring a section of code
(e.g. a function), it should be dependent name on template parameter
and could only be resolved when instantiation is done.
Can you cite the section of the C++ standard where this requirement is
stated? The definition of the term "dependent name" in my copy of the
standard seems to be different from your description. It doesn't seem to
mention your "identify the type of variable" step.
Compilers routinely parse template definitions without knowing all the
types involved. That's the whole point of a template, after all.
You are stuck with this notion that every entity must be associated with
a concrete type. With templates, this is not the case. An entity may be
associated with a parameterized (templated) type, which only becomes
concrete once the template is instantiated. A name referring to such an
entity is not a dependent name.
A dependent name is one that refers to, or otherwise depends on, the
_internals_ of a parameterized type (e.g. its members or its associated
namespaces). With such names, you can't even figure out _which_
declaration the name refers to, let alone the type of the referred-to
entity, until the template is instantiated and the parameterized type
becomes concrete.
In my understanding, each type has an identifier and compiler needs
to match variable with related type identifier (like typeid typeof
operator, giving variable a type tag).
Eventually, yes. With templates, this happens at the point of
instantiation.
For the sample, how could
compiler identify what type of v is?
It's std::vector<SomeType>&, where SomeType is the template argument for
template parameter T which the template is instantiated with.
So, I think v is dependent on
template parameter.
You seem to be using a definition of the term "dependent name" I'm
unfamiliar with. One different from that specified in the standard.
I do not understand why it is treated as a template parameter
non-dependent name in your minds and also in Bjarne's points.
And also in the C++ standard, which is what really matters.
--
With best wishes,
Igor Tandetnik
With sufficient thrust, pigs fly just fine. However, this is not
necessarily a good idea. It is hard to be sure where they are going to
land, and it could be dangerous sitting under them as they fly
overhead. -- RFC 1925