Re: question about stream operator and namespaces
Russell McManus <russell_mcmanus@yahoo.com> writes:
namespace foo
{
template <class T>
class Wrapper
{
public:
Wrapper() {}
explicit Wrapper(T const& t) : _t(t) {}
T const& operator()() const { return _t; }
private:
T _t;
};
}
template <class T>
ostream& operator<<(ostream& os, foo::Wrapper<T> const& t) {
os << t(); return os;
}
Move this definition of operator<<() into namespace foo and you'll be
fine.
It's true that this program works if you move operator<< into
namespace foo. Why doesn't it work as is?
Because the global namespace isn't among the namespace where the
operator is looked for.
The code invoking the the operator<<() is in a member of the
ostream_iterator template, which belongs to name std. The types of the
arguments are std::ostream and foo::t. operator<<() candidates is
therefore first searched in namespaced std and foo; since the set of
candidates found in these namespaces is not empty, no other namespace
will ever be considered, not even the global namespace.
I ask because this simple example was extracted from a larger
program. If I take the approach of moving operator<< into the
namespace in the larger program, then various other things that
naively look OK fail to compile.
My guess is that the code invoking operator<< is wrong.
I seem to remember reading a C++ article once advising that stream
operators should be defined at the global level to avoid various
problems.
This soulds like bad advice. It's hard to argue without knowing the
article, in particular these problems.
Are there any general rules of thumb to follow here?
Yes.
Operators should belong to the same namespace as the class to whose
interface they belong.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]