Re: cout << vector<string>

From:

Maxim Yegorushkin <maxim.yegorushkin@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Tue, 11 Nov 2008 09:17:10 -0800 (PST)

Message-ID:

<074b6e30-34da-4259-89c0-ef93f0ed63c3@40g2000prx.googlegroups.com>

On Nov 11, 4:39 pm, Hendrik Schober <spamt...@gmx.de> wrote:

Maxim Yegorushkin wrote:

On Nov 11, 3:36 pm, Hendrik Schober <spamt...@gmx.de> wrote:

Maxim Yegorushkin wrote:

On Nov 11, 2:40 pm, Hendrik Schober <spamt...@gmx.de> wrote:

Maxim Yegorushkin wrote:

[...]

    #include <map>
    #include <iostream>
    #include <iterator>
    // should be in namespace std::
    template<class T, class U>
    std::ostream& operator<<(std::ostream& s, std::pair<T, U> c=

onst& p)

    {
        return s << p.first << ' ' << p.second;
    }
    int main()
    {
        typedef std::map<int, int> Map;
        Map m;
        std::copy(
              m.begin()
            , m.end()
            , std::ostream_iterator<Map::value_type>(st=

d::cout)

);
}
It won't compile unless operator<<(std::ostream& s, std::pair<T, U>
const& p) is in namespace std.

  I would have asked the same question for this code. :)
  I don't understand why it doesn't compile. It comes down
  to this
    ostr << val;
  with 'ostr' being an 'std::basic_ostream<>' and 'val'
  being an 'std::pair<>'. Why doesn't this find the global
  operator?

Because expression "ostr << val" is template argument dependent and
thus is bound at the second phase of the two-phase name lookup. At th=

second phase it uses ADL only to search for functions within
namespaces associated with ostr and val. ostr is std::basic_ostream
and val is std::pair<int, int>, thus one associated namespace is std.
int has no associated namespaces. So, the only namespace considered
for expression "ostr << val" is std, which lacks a suitable
operator<<().

But lookup isn't ADL only. The enclosing namespaces are considered=

too, aren't they? And the global namespaces is always enclosing.
(I'm not saying you're wrong. I just don't understand this.)

At the second stage of the two-phase name lookup (at the point of
template instantiation) it is ADL only.

  I'm trying to come up with some trivial example that
  illustrates this, but I fail. I have this

     #include <iostream>

     namespace N {
         struct test { };

         template< typename T >
         void f(T) { std::cout << "f(T)\n"; }

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

     template< typename T >
     void g(T o) { f(o); }

     int main()
     {
         N::test t;
         g(t);
     }

  which compiles fine and gives the expected result.
  What am I still missing.

Your example should work just fine.

Here is a simplified version of the problem with
std::ostream_iterator<std::pair<> > and a global
operator<<(std::ostream&, std::pair<>):

    namespace N {

    struct X {};

    void bar(struct overload_for_compilers_with_no_two_phase_lookup&);

    template<class T> void foo(T t) { bar(t); }

    }

    template<class T> void bar(T);

    int main()
    {
        N::X x;
        foo(x);
    }

--
Max