Why I cannot put this operator overload in the same namespace as the struct?

Question

I have the following code:

#include <iostream>
#include <vector>
namespace X {
    std::ostream& operator<<(std::ostream& os,const std::vector<double>& v){
        for (int i=0;i<v.size();i++){os << v[i] << " ";}
        return os;
    }
    namespace Y {
        struct A {std::vector<double> x;};    
        std::ostream& operator<<(std::ostream& os,const A& a){
            os << a.x << std::endl;
            return os;
        }
   }     
}

using namespace X;

int main(int argc, char** argv) {
   std::vector<double> v(10,0);
   std::cout << v << std::endl;
   Y::A a;
   std::cout << a << std::endl;
   return 0;
}

The first overload works, but the second one does not. For some reason it cannot find the first one. I get the error:

no match for 'operator<<' (operand types are 'std::ostream 
{aka std::basic_ostream<char>}' and 'const std::vector<double>')
     os << a.x << std::endl;
        ^

I do not understand why I get this error. For example something like this seems to be completely valid:

namespace A {
    void foo(){}
    namespace B {
        void bar(){foo();}
    }
}

However, the only way to fix the above problem was to put the second overload also in X. Why is it not possible to have it in the same namespace as the struct (ie. X::Y)?

PS: I was reading on ADL and I found some related questions (e.g. this and this, but what I understood from reading this, the above should work.

@0x499602D2 Yes, that works and is much nicer than moving the overload to `X`. Still it would be nice to know why ADL does not apply in this case. — 463035818_is_not_an_ai, May 06 '15 at 15:28

Richard Hodges · Answer 1 · 2015-05-06T15:34:25.513

2

As per other answers, I eventually deduced that ADL of operator<< was being impeded by the fact that it was taking place inside another operator<<.

Today's lesson: always write an operator<< overload in terms of a writer method :)

Here's the fix:

#include <iostream>
#include <vector>


namespace X 
{
    std::ostream& operator<<(std::ostream& os,const std::vector<double>& v){
        for (int i=0;i<v.size();i++){os << v[i] << " ";}
        return os;
    }
    namespace Y 
    {
        struct A 
        { 
            std::vector<double> x;
            void write(std::ostream&os) const {
                os << x << std::endl;
            }
        };    
        std::ostream& operator<<(std::ostream& os,const A& a)
        {
            a.write(os);
            return os;
        }
    }     
}

using namespace X;

int main(int argc, char** argv) 
{
   std::vector<double> v(10,0);
   std::cout << v << std::endl;
   X::Y::A a;
   std::cout << a << std::endl;
   return 0;
}

edited May 06 '15 at 15:34

answered May 06 '15 at 15:18

Richard Hodges

68,278
7
90
142

Then why is the foobar example ok? Btw I did not expect the `using namespace X` to have any influence on the problem. I just put it to have access to `X` in the main. – 463035818_is_not_an_ai May 06 '15 at 15:23
I mean `namespace Y` is declared inside `namespace X`, just as `B` is inside `A` and thus `bar` can call `foo` – 463035818_is_not_an_ai May 06 '15 at 15:24
looks reasonable, however I would like to avoid using some writer method. Also, in my real problem, it really would be much more comfortable to use already existing "<<" of components to implement the "<<" of a bigger struct/class. – 463035818_is_not_an_ai May 06 '15 at 15:37
sorry didnt read your code carfully enough. You are using the vectors << to implement the structs <<. Actually now I am a bit confused ;) I will have to take another look when I have time. – 463035818_is_not_an_ai May 06 '15 at 15:40
@tobi303 no, my code is essentially the same as yours except `X::Y::operator<<` defers to `X::Y::A::write` rather than trying to call `X::operator<<` directly (because that is being hidden by the enclosing function's name). Calling operator<< from an operator<< when relying on ADL is a no-go. You can defer to a free function if you prefer, but you can't lookup the same name as yourself. – Richard Hodges May 06 '15 at 15:43

Mateusz Grzejek · Accepted Answer · 2015-05-06T15:36:57.967

2

In Argument Depended Lookup (or Koenig Lookup), compiler adds to the scope of visibility all symbols declared in parent scopes of each parameter.

Even if Y is "child namespace" of X, they are not related in terms of ADL. First of your parameters is type defined in std:: namespace, while second is local symbol (defined in the same namespace as the function itself).

Note, that because of reasons mentioned above, you will most likely get another error in this line:

std::cout << v << std::endl;

when compiler will not be able to find operator<< overloaded for std::vector<double> (because it lies inside namespace X).

To solve this, you can use:

using X::operator<<

inside namespace Y or move that overload.

If you are wondering, why foobar example works: that's because ADL (Argument Dependent Lookup) is about scope of parameters of functions, not functions themselves. In foobar code, ADL isn't applied.

edited May 06 '15 at 15:36

answered May 06 '15 at 15:31

Mateusz Grzejek

11,698
3
32
49

Nice explanation. I didnt get the error for the vector because of `using namespace X`. I guess then the answer to where to put the overloads of `<<` is different from what was answered [here](http://stackoverflow.com/questions/171862/namespaces-and-operator-overloading-in-c). Should I put them in global namespace or even in std? – 463035818_is_not_an_ai May 06 '15 at 15:34
I would put them in global namespace, using fully-qualified types of parameters (`std::vector` and `X::a`). – Mateusz Grzejek May 06 '15 at 15:38

Raydel Miranda · Answer 3 · 2015-05-06T15:50:17.950

As simple as this: In order to overload a function the overloaded version have to lives in the same nemaspace, otherwise, is a completely different function. The name of the function (for the compiler) is the complete path from the global namespace to the function itself.

::function_at_global_namespace();
Namespace::function_name();      // Some funtion within a namespace;
Namespace_1::function_name();    // Some other function within another namespace;

So,

Standar std::ostream& operator<< lives in std namespace, you are not overloading that operator, Just defining anotherone in namespace X.

As pointed by @0x499602D2 you must use X::operator<< in namespace Y in order to call that version of the operator.

std::ostream& std::operator<< and std::ostream& X::operator<< are diferent functions.

In following code none of the foo versions are overloading either.

// What version of foo gets called?  A::foo, or B::foo?
namespace A {
    void foo(){cout << "A::foo" << endl;}
    namespace B {
        void foo(){ cout << "B::foo" << endl;}
        void bar(){foo();}
    }
}

namespace C { void foo(int a) { cout << "C:foo" << endl; } }

good point. But then I do not really understand why ADL does not apply in this case. — 463035818_is_not_an_ai, May 06 '15 at 15:30
From `main()`, it is not ADL that resolves the first use of `operator<<`, but the fact you said `using namespace X`. The second use of `operator<<` in `main()` resolves to `X::Y`s version due to ADL. From `X::Y`, there is no `using`, so it is using ADL. But, the arguments are in the `std` namespace, so that is where ADL looks. — jxh, May 06 '15 at 15:33

Why I cannot put this operator overload in the same namespace as the struct?

3 Answers3