Stefan said:There have been many announciations that VC 8.0 will finally support
two phase template lookup; now, after I installing VC 2005 Express I
had to realize that it still doesn't!
What has happend to these plans???
Carl said:Where have you seen such an announcement?
Stefan said:I've not seen it, but I've heard it several times (also from Herb
Sutter); many people in the C++ community are currently ensured that
this feature will be part of the next compiler release!
Carl Daniel said:I confirmed with the VC++ team that there are no plans to support two-phase
lookup for Whidbey. I've never seen a statement that such support would be
in Whidbey, so I'd be very curious to see a reference to any such claims.
krazyman said:From http://msdn.microsoft.com/chats/vstudio/vstudio_022703.asp
Host: Herb (Microsoft)
Q: What are current plans as far as becoming compliant wrt two-phase
name lookup?
A: That's one of the three things we didn't implement in Everett (the
others were enforcing exception specifications and export). Two-phase
lookup is related to export, so see also the export answer above. One
issue with two-phase lookup is that when we (or any compiler)
provide(s) it, we'll have to consider migration for users -- two-phase
lookup breaks a LOT of existing code, which is one reason it is not
widely implemented in compilers today. (IIRC, EDG supports it in
strict mode, Metrowerks supports it but you need to throw
-iso_templates on (even -ansi strict isn't enough), and IBM used to
support it as an option but no longer does (even as an option). The MW
and IBM situations are because of breaking code.) BTW, I'm giving a
talk about this at SD West in a few weeks, for those who are in the
Bay area and may be interested --
http://www.cmpevents.com/sdw/a.asp?option=3&V=11&SessID=530. (BTW, I
don't know of any other compiler besides those three that does/did
support 2-phase lookup. Did I miss any?)
Russell Hind said:Can someone point me to a link that describes how two-phase look-up
works, and why implementing it will break current code? I've had a
quick search with google, but haven't come up with much help yet.
Bo said:This of course makes the lookup dependent on the order of the
declarations, which is a huge change.
Bo said:The two-phase lookup is used to determine how to find non-dependent
names (not depending on the template parameters) in a template
definition. Accorning to the standard, the lookup should be performed in
the context of the template's not in the context of its use. The
standard document gives this example:
void g(double);
void h();
template<class T> class Z
{
public:
void f()
{
g(1); //calls g(double)
h++; //illformed: cannot increment function;
// this could be diagnosed either here or
// at the point of instantiation
}
};
void g(int); // not in scope at the point of the template
// definition, not considered for the call g(1)
This of course makes the lookup dependent on the order of the
declarations, which is a huge change.
Ioannis said:If I get it correctly, according to the standard void g(int); wouldn't
be considered to be used inside template class Z, however this is the
rational thing to be expected or am I wrong? Doesn't the same already
apply for ordinary class and function definitions?
Russell said:For non-template classes yes, if g(double) wasn't declared there would
be an error.
However, for template stuff, the method code isn't really compiled until
you actually use it, so by the time you use it, both
g(double) and
g(int)
have been declared, so which would be called? templates behave
differently from non-template classes because the method compilation
doesn't take place until instantiation.
I think thats correct, anyway.
If I get it correctly, according to the standard void g(int); wouldn't
be considered to be used inside template class Z, however this is the
rational thing to be expected or am I wrong? Doesn't the same already
apply for ordinary class and function definitions?
Stefan said:void g(float) {}
template<typename T> void f(T t) {
g(t);
}
void g(double) {}
int main() {
f(1);
}
Here, the argument t in g(t) _is_ dependent, but ADL does not add viable
candidates to the overload set. Thus, this call _must not_ be ambigous!
(=my favourite test case on two-phase lookup...)
Russell said:I don't read this as 'two-phase look up will be in Whidbey'. Consider
the statement
"One issue with two-phase lookup is that *when we* (or any compiler)
provide(s) it, we'll have to consider migration for users"
Ioannis said:However if the above is:
void g(float) {}
template<typename T> void f(T t)
{
g(t);
}
void g(int) {}
int main()
{
f(1);
}
according to the standard, which one should be called?
Stefan said:It's the same - the second g is no candidate for the overload set (it's
not seen at the time of parsing the template).
krazyman said:"Carl Daniel [VC++ MVP]"
I confirmed with the VC++ team that there are no plans to support
two-phase
lookup for Whidbey. I've never seen a statement that such support
would be
in Whidbey, so I'd be very curious to see a reference to any such
claims.
From http://msdn.microsoft.com/chats/vstudio/vstudio_022703.asp
Ioannis Vranos said:OK then, it seems I haven't understood yet. So what would be different
with the two phases?
Bo said:The big difference is that different sets of overloads can be seen at
different points of use of the template. They should all be using the
same g(float) anyway. This isn't considered in most of existing code.
I have heard stories about when HP first tried to implement this, and
almost nothing would compile, not even the standard library. It took
them a while to realize that the compiler was actually right, and that
they immediately had to add a switch to turn the new features off!