简体   繁体   中英

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

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 (eg this and this , but what I understood from reading this, the above should work.

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;
}

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.

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; } }

The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM