Template func and non template func call order - c++

Question

In Linux I get
template max() is called
But under Windows I get
non-template max() is called
Why? In Linux, I use gcc 4.5 and in Windows I use VS2008.
#include <iostream>
#include <vector>
template < typename T >
inline void max( const int& a, const T& b )
{
std::cout << "template max() is called" << std::endl;
}
template < typename T >
inline void Imax( const int& a, const std::vector<T>& b)
{
max(a, b[0]);
}
inline void max( const int& a, const int& b )
{
std::cout << "non-template max() is called" << std::endl;
}
int main()
{
std::vector<int> v;
v.push_back(1);
Imax(1, v);
return 0;
}

Answer 1

In pre-standard C++, you would likely get the non-template max.
(Without a standard, it's hard to say what you should get, but all of
the pre-standard compilers I know would defer name-lookup to
instantiation.) Since C++89, you should get template max; name lookup
occurs in two phases: when the template is defined (at which point, only
the template max is visible), and when the template is instantiated,
but at the instantiation point, only for dependent names, and only using
ADL. In your code, max is a dependent name, but the symbols
triggering ADL are std::vector (which draws in std) and int, which
doesn't add anything, not even the global namespace. So the
non-template max is not found.
These rules were among the last formalized by the C++ committee, and
compilers can't change overnight, so practically speaking, if the
compiler dates from anytime before 1995, you can probably expect the
pre-standard behavior. For anything later, I'd tend to consider it a
compiler error, but... compilers have to support existing code, and
ideally, later compilers will have an option to use the previous name
lookup rules. (I say ideally, because having two incompatible sets of
name lookup rules is decidedly non-trivial. Just getting one set
correct is difficult enough for most compiler implementors.)
And it's fairly well known that Microsoft's implementation of templates
is not standard conformant, even today.

Answer 2

The call of max in Imax depend on T and thus max should be searched in the template definition context (where the template max is) and combined with the argument dependent lookup in the instantiation context. ADL shouldn't find the free standing max as int have no associated namespace. So my take is that gcc is correct.
Note that if you have the slight variation:
#include <iostream>
#include <vector>
struct S {};
template < typename T >
inline void max( const S& a, const T& b )
{
std::cout << "template max() is called" << std::endl;
}
template < typename T >
inline void Imax( const S& a, const std::vector<T>& b)
{
max(a, b[0]);
}
inline void max( const S& a, const S& b )
{
std::cout << "non-template max() is called" << std::endl;
}
int main()
{
std::vector<S> v;
v.push_back(S());
Imax(S(), v);
return 0;
}
here, the global namespace is associated with S, and thus the non template max is found by the ADL lookup at the point of instantiation.