朋友声明：这是clang中的错误吗？

Question

§3.4.1/3 has the following example:

typedef int f;
namespace N
{
    struct A
    {
        friend void f(A &);
        operator int();
        void g(A a)
        {
            int i = f(a);
        }
    };
}

Which compiles without errors (see live example ) as the compiler doesn't see the friend declaration N::A::f(A&) in the ordinary lookup for the name f in the declaration int i = f(a); and this is correct according to §7.3.1.2/3.

§7.3.1.2/3 (emphasis is mine):

Every name first declared in a namespace is a member of that namespace. If a friend declaration in a nonlocal 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) until a matching declaration is provided in that namespace scope ( either before or after the class definition granting friendship ).

Now if we include the declarations

struct A;
void f(A&);

In the snippet above in namespace N , before the struct A , the code will correctly emit an error (see live example ), as now the function ::f(A&) is found by ordinary lookup for the name f in the expression int i = f(a); and this is in accordance with §7.3.1.2/3.

However, if we include the declaration

void f(A&);

In namespace N , after the struct A , the code surprisingly doesn't emit any error, see live example .

Answer 1

No, clang is doing the right thing. This is not a bug.

You are misreading the context of this spec excerpt. The only thing this paragraph is communicating relates to how friend function declarations and their target function get associated with each other. It has nothing whatsoever to do with the usual rules around calling that particular function, and changes nothing in that regard.

Compilation therefore does not fail because the prototype of the function f() has not yet been declared at the point you attempt to use it (and instead it finds the typedef with the same name).

If you alter your code to implement the A::g() member outside of the class, you will note that compilation fails when the f() prototype appears before the implementation and succeeds when the prototype appears after it -- exactly what you would expect to happen if the friend declaration was absent.

Answer 2

In the same paragraph you cited ( §7.3.1.2/3 ) there is an example clarifying the lookup rules:

// Assume f and g have not yet been defined.
void h(int);
template <class T> void f2(T);
namespace A {
    class X {
        friend void f(X); // A::f(X) is a friend
        class Y {
            friend void g(); // A::g is a friend
            friend void h(int); // A::h is a friend
            // ::h not considered
            friend void f2<>(int); // ::f2<>(int) is a friend
        };
    };

    // A::f, A::g and A::h are not visible here
    X x;
    void g() { f(x); } // definition of A::g
    void f(X) { /* ... */} // definition of A::f
    void h(int) { /* ... */ } // definition of A::h
    // A::f, A::g and A::h are visible here and known to be friends
}

So the compiler works correctly.