Question: > 
> **Possible Duplicate:**  
> 
> [Where should non-member operator overloads be placed?](https://stackoverflow.com/questions/3623631/where-should-non-member-operator-overloads-be-placed) 
> 
> 
> 

While browsing on SO, I often find questions or answer that involves overloading/defining a `std::ostream& operator<<(std::ostream& os, const Foo& foo)` or a `Foo operator+(const Foo& l, const Foo& r)`.

While I know how and when (not) to write these operators, I'm confused about the `namespace` thing.

If I have the following class:

```
namespace bar
{
  class Foo {};
}

```

In which `namespace` should I write the different operator definitions ?

```
// Should it be this

namespace bar
{
  std::ostream& operator<<(std::ostream& os, const Foo& foo);
}

// Or this ?

namespace std
{
  ostream& operator<<(ostream& os, const bar::Foo& foo);
}

// Or this ?

std::ostream& operator<<(std::ostream& os, const bar::Foo& foo);

```

The same question applies for the `operator+`. So, what is the good practice here and **why** ?

Answer: 
For operator overloading to work correctly, the function must be
in the same namespace as one of its operands. Otherwise, ADL
doesn't find it. This means the namespace of your class for
operators like + and -. Theoretically, you could put operator<<
in either std or the same namespace as your class, but the
standard forbids defining new functions in std, so here too, you
put it in the same namespace as the class.

(And of course, you don't usually implement + or -, but += and
-=, and then derive from a template which provides + and
- automatically.)
The good practice is to declare the (non-member) operators in the same namespace as the class whose interface they belong to.

For something like `operator+`, this is rather easy: It operates only on Foo objects, so it should go in the same namespace as Foo itself.
For `operator<<` and `operator>>`, you could still chose between namespaces `std` and `bar`. First of all, you are not supposed to add function/operator overloads to namespace `std`. And secondly, the important part of these overloads is not that they work with a stream, but that they read/write a Foo object. So it makes more sense to bundle it with the Foo class.

It should also be noted that the rules of C++ are designed such that overloaded operators that are defined in the same namespace as the class they operate on, will almost always be correctly found, while this will go wrong much more often if the operators are declared in some other, unrelated, namespace.