Ambiguous overload for operator when in different namespaces

Question

File A.hpp:

struct foo
{
   int x;
} foo;

inline bool operator ==(const foo &lhs, const foo &rhs)
{
   /* ... */
}

File B.hpp

#include "A.hpp"

namespace SomeNamespace
{
   bool operator==(const foo &lhs, const foo &rhs)
   {
      /* ... */
   }

   /* ... */
   void someFunction(const foo &foo_instance1, const foo &foo_instance2)
   {
      CPPUNIT_ASSERT(foo_instance1 == foo_instance2);
   }
}

The compiler error for the line with the ASSERT is:

error: ambiguous overload for 'operator==' ...

So, the problem is that the compiler sees both comparison operators.

The definition in the global namespace of A.hpp and the definition in the SomeNamespace of B.hpp are ambiguous.

Why does the compiler not use the defintion in the SomeNamespace?

And foo_instance1 is....? Please try to provide an SSCCE when asking a question. — Angew is no longer proud of SO
– Angew is no longer proud of SO, Commented Sep 12, 2013 at 12:12

James Kanze · Accepted Answer · 2013-09-12 12:33:59Z

2

You've defined the same function twice; what do you expect to happen? The compiler finds SomeNamespace::operator== with unqualified name lookup, and ::operator== with ADL. Since both have exactly the same signature, there is no way for the compiler to choose one over the other.

As a general rule, overloaded operators for a type should be defined in the same namespace as the type, and no where else. (If the overloaded operator takes two different types, defined in two different namespaces, I'd put the operator in the global namespace. But such cases are rare.)

answered Sep 12, 2013 at 12:33

James Kanze

155k20 gold badges191 silver badges338 bronze badges

Sign up to request clarification or add additional context in comments.

8 Comments

jrok Over a year ago

I didn't know ADL also looks in global scope (if that's what you mean?).

lapk Over a year ago

@JamesKanze Can you explain the difference, please: with struct and with namespace?

Juergen Over a year ago

Ok, is see that ADL is the actual "problem" since foo and its == operator are defined in the same(global) namespace. So this definition is considered as also the definition in the "local" namespace. Thx

James Kanze Over a year ago

@PetrBudnik The difference in what?

James Kanze Over a year ago

@jrok ADL looks in namespaces implied by the arguments; in this case, it looks in the global namespace because that's where foo was defined.

|

shofee · Accepted Answer · 2013-09-12 12:51:29Z

2

In your program operator== is defined in Global namespace and Somenamespace.

So when you are trying to access the operator== then compiler is unable to resolve which function to call, as both functions have same signature ans both are visible to compiler.

So to use operator== defined in SomeNamespace you must use SomeNamespace::operator== and for the operator define in Global namespace you must use ::operator==.

answered Sep 12, 2013 at 12:51

shofee

2,12915 silver badges31 bronze badges

11 Comments

Juergen Over a year ago

What are the lookup rules? I thought that the operator== in SomeNamespace is considered first since it should be found first.Isn't it that the compiler searches for names in a bottom-up-like manner(of the namespaces) and stops when the first correct definition is found?

shofee Over a year ago

its not about top-to-bottom or bottom-up. When you are compiling the code compiler has both the functions visible "at same time".

lapk Over a year ago

@shobi Can you explain the difference, please: with struct and with namespace?

shofee Over a year ago

@Juergen pls refer this stackoverflow.com/questions/7374588/…

shofee Over a year ago

@PetrBudnik sorry i didnt get u.

|

Collectives™ on Stack Overflow

Ambiguous overload for operator when in different namespaces

2 Answers 2

8 Comments

11 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

8 Comments

11 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related