Question

Trying to make a class friends with an extern "C" function, this code works:

#include <iostream>

extern "C" {
  void foo();
}

namespace {
  struct bar {
    // without :: this refuses to compile
    friend void ::foo();
    bar() : v(666) {}
  private:
    int v;
  } inst;
}

int main() {
  foo();
}

extern "C" {
  void foo() {
    std::cout << inst.v << std::endl;
  }
}

But I was very surprised to find that with g++ 4.6.1 and 4.4.4 I have to explicitly write :: in friend void ::foo(); otherwise the friendship doesn’t work. This :: is only needed when it’s extern "C" though.

1. Is this a compiler bug/problem? I wasn’t expecting that behaviour.
2. If it isn’t a bug why is this required, but only when it’s extern "C" and not without it? What about the name lookup rules changes that makes this necessary?

I’m stumped. There is probably some rule for this that I can’t find.

Answer 1

[n3290: 7.3.1.2/3]: Every name first declared in a namespace is a
member of that namespace. If a friend declaration in a non-local class
first declares a class or function the friend class or function is a
member of the innermost enclosing namespace. The name of the friend is
not found by unqualified lookup (3.4.1) or by qualified lookup (3.4.3)
95) this implies that the name of the class or function is
unqualified. until a matching declaration is provided in that
namespace scope (either before or after the class definition granting
friendship). If a friend function is called, its name may be found by
the name lookup that considers functions from namespaces and classes
associated with the types of the function arguments (3.4.2). If the
name in a friend declaration is neither qualified nor a template-id
and the declaration is a function or an elaborated-type-specifier, the
lookup to determine whether the entity has been previously declared
shall not consider any scopes outside the innermost enclosing
namespace. [..]

The innermost enclosing namespace is the anonymous one, and you didn’t qualify the function name, so the name is not found.

The namespace need not be anonymous, either.

Note that the extern "C" in the question is a red herring, as the following also fails for the same reason:

void foo();

namespace {
struct T {
   friend void foo();

   private: void bar() { cout << "!"; }
} t;
}

void foo() { t.bar(); }

int main() {
   foo();
}

/*
In function 'void foo()':
Line 7: error: 'void<unnamed>::T::bar()' is private
compilation terminated due to -Wfatal-errors.
*/

[alternative testcase, adapted from your original code]