Defining a custom equality operator in an anonymous namespace

Question

I have a C-struct (in a C header file) that looks like so:

struct Foo {
  int a;
  int b;
  int c;
};
typedef struct Foo Foo;

I want to test equality of two vectors of these structs, and so I would like to define a custom equality operator for this struct for just my translation unit.

I am able to do so with

static inline bool operator==(const Foo&, const Foo&) {...}

but not with

namespace {
    bool operator==(const Foo&, const Foo&) {...}
}

Why can the equality template for std::vector not find this operator, and is there a better way than tossing a static inline in the global namespace?

I'd like to vote to close this as a duplicate of [ADL for class in anonymous namespace](https://stackoverflow.com/questions/52629859/adl-for-class-in-anonymous-namespace), but I'm not confident enough to actually vote (because doing so would use my gold-badge dupe hammer). — Cornstalks, Mar 28 '19 at 04:50
Researched anonymous namespaces, found [this](https://stackoverflow.com/a/357427/10957435) and [this](https://stackoverflow.com/a/357431/10957435) which might help answer your question. — , Mar 28 '19 at 04:50
@Cornstalks: It's not the same, in that question both the user-defined type and the related functions are in the anonymous namespace, here the user-defined type is not in the anonymous namespace at all. — Ben Voigt, Mar 28 '19 at 05:30
I think this may actually be a duplicate of https://stackoverflow.com/q/33434606/103167 despite the fact this one involves an operator and some library code — Ben Voigt, Mar 28 '19 at 05:43

Ben Voigt · Accepted Answer · 2019-03-28T05:45:14.933

I think you'll find that std::vector actually does find the operator in the anonymous namespace, if that operator's declaration occurs before #include <vector>.

The reason it doesn't find it in your code is related to the two-phase lookup for names in template functions. The first phase finds candidates in all namespaces in scope. The second phase only finds dependent names. "Argument-dependent lookup" which searches the namespace containing the type is dependent just as the phrase says. Lookup in the anonymous namespace is not dependent, so it won't be done during the second phase.

See also:

Great answer Ben! This gives me both a good explanation as well as a set of concrete tradeoffs to weigh. — Mark Pauley, Mar 28 '19 at 07:54

R Sahu · Answer 2 · 2019-03-28T05:36:40.473

The first thing to be noted is that an anonymous namespace is not the same as no namespace.

namespace
{
    bool operator==(const Foo&, const Foo&) {...}
}

is really something like

namespace ANameUniqueToTheFile
{
    bool operator==(const Foo&, const Foo&) {...}
}

using ANameUniqueToTheFile;

with the downside that the language does not give you the ability to get the name of the namespace.

For that reason, the operator== function defined in the anonymous namespace is not found using ADL.

I can see why you would want to put the operator== function in a namespace. One possbile way to do that would be to #include the .h file that defines the struct inside a named namespace.

FooWrapper.h:

namespace MyApp
{
   #include "foo.h"

   // Declare the function.
   bool operator==(Foo const& lhs, Foo const& rhs);
}

FooWrapper.cpp

#include "FooWrapper.h"

namespace MyApp
{
   // Implement the function.
   bool operator==(Foo const& lhs, Foo const& rhs) { ... }
}

However...

I realize that I'm simplifying a bit about what's in "foo.h". Adding all of them in namesapce MyApp might not be appropriate, specially if "foo.h" includes other .h files and/or standard header files. I am hoping it gives you some ideas on how to tackle the problem.

If putting all of "foo.h" in namespace MyApp does not work smoothly, it will probably be expedient to define the operato== function in global scope.

Including headers in a namespace is almost always a bad idea. Consider what happens if standard library headers are included transitively. — Eric, Mar 28 '19 at 05:32
@Eric, agreed. I updated the answer to address that concern. — R Sahu, Mar 28 '19 at 05:39
Not only that, you get linker errors if there's an accompanying .c file. — Passer By, Mar 28 '19 at 06:10
@PasserBy: No you don't. I mean, obviously if the definitions are written in C, you must be using `extern "C"`, and when you do the namespace is not part of the externally-visible name. — Ben Voigt, Mar 28 '19 at 14:14

Defining a custom equality operator in an anonymous namespace

2 Answers2

However...