14.6.3 Non-dependent names [temp.nondep]

1 Non-dependent names used in a template definition are found using the usual name lookup and bound at the
point they are used. [Example:

    void g(double);
    void h();

    template<class T> class Z {
    public:
        void f() {
            g(1);                           // calls g(double)
            h++;                           // ill-formed: 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)

—end example]

#include <iostream>

void g(double) { std::cout << "void g(double);\n"; }

template<class T> class Z {
public:
    void f() { g(1); }
};

void g(int) { std::cout << "void g(int);\n"; }

int main()
{
    Z<int> z;
    z.f();
}

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 don't know of any other compiler besides those three that does/did support 2-phase lookup. Did I miss any?)

#include <utility>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

template <typename Ch, typename Tr>
inline basic_ostream<Ch, Tr>& operator<<(basic_ostream<Ch, Tr>& out, pair<int, int> const& x)
{
    return out << '(' << x.first << ',' << x.second << ')';
}

int main()
{
    vector<pair<int, int> > v;
    copy(v.begin(), v.end(), ostream_iterator<pair<int, int> >(cout, "\n"));
}

I>#include <utility>
I>#include <iostream>
I>#include <algorithm>
I>#include <vector>

I>using namespace std;

I>template <typename Ch, typename Tr>
I>inline basic_ostream<Ch, Tr>& operator<<(basic_ostream<Ch, Tr>& out, pair<int, int> const& x)
I>{
I>    return out << '(' << x.first << ',' << x.second << ')';
I>}

I>int main()
I>{
I>    vector<pair<int, int> > v;
I>    copy(v.begin(), v.end(), ostream_iterator<pair<int, int> >(cout, "\n"));
I>}
I>

#include <utility>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

template< class T >
struct Wrap : public T
{
  Wrap(T const &val) : T(val) {}
};

template <typename Ch, typename Tr>
inline basic_ostream<Ch, Tr>& operator<<(basic_ostream<Ch, Tr >& out, pair<int, int> const& x)
{
    return out << '(' << x.first << ',' << x.second << ')';
}

int main()
{
    vector<pair<int, int> > v(2);
    v[0] = make_pair(0, 0);
    v[1] = make_pair(1, 1);
    copy(v.begin(), v.end(), ostream_iterator< Wrap< pair<int, int> > >(cout, "\n"));
}