Re: [Mingw-users] Template Bug or proper behaviour?

[Aaron W. L. <aar...@aa...>]

HERNANDEZ CORDOBA RODRIGO JOSE wrote:

> So, the question is, is this a bug or due to standards becoming
> stricter? if the later, what is the workaround?

This behavior is correct, and as you said, comes from improvements to
conformance with the C++ standard.  In particular, the C++ parser was
completely rewritten for GCC 3.4.

First, a slightly simplified testcase:
// #define SCOPE

void overloaded_function(char *);

template<typename T>
struct some_class {
  void member_function(T t) {

#ifdef SCOPE
    ::overloaded_function(t);
#else
    overloaded_function(t);
#endif

  }
};

void overloaded_function(int);

int main() {
  some_class<int> c;
  c.member_function(2);

  return 0;
}
-

overloaded_function() in some_class<T>::member_function(T) is called a
dependent name, because it depends on the type of a template parameter
to be resolved.

Without SCOPE defined, when member_function() is instantiated, a
two-stage lookup is performed.  (This is also called "Keonig lookup.")
First, declarations visible at the point of definition of
member_function() are searched.  Since the only overloaded_function()
declaration visible here is incompatible, this search is unsuccessful.

Then, namespaces from both member_function()'s definition context and
the instantiation context (in main()) associated with the type of all
parameters to member_function() are searched.  In this case, the global
namespace is searched.  Unlike in the previous search, which only
searched declarations availible at the point of definition, this search
examines the entire namespace, and so finds the compatible name.

However, with SCOPE defined, the scope resolution operator is used.
This has the affect of disabling this two-stage lookup, and instead only
searching in the specified namespace at the point of definition.  Since
the only declaration visible at this point is incompatible, an error is
generated.

It's interesting to see that MSVC 7.1, for all its claims of
conformance, and the extremely deep pockets of its creator, still does
not match GCC.

If you have any more questions about this, you could probably get even
more precise answers from the newsgroup comp.std.c++.


Aaron W. LaFramboise