Question

Possible Duplicate:
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 1

It should be in the bar namespace. You must consider what makes up the interface for the class, and group those together.

“A class describes a set of data along with the functions that operate on that data.” Your free function operates on a Foo, therefore it is part of Foo. It should be grouped with Foo in the namespace bar.

Argument-dependent lookup, or ADL, will find the function.

We also know that we should prefer non-friend non-member functions. What this means is that, in general, your classes will have their definition and member functions, followed immediately by free functions which operate on the class.